make generate
This commit is contained in:
parent
0ebbc6708d
commit
bb11d69772
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,977 @@
|
|||
// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
|
||||
// source: node/v1/node.proto
|
||||
|
||||
/*
|
||||
Package nodev1 is a reverse proxy.
|
||||
|
||||
It translates gRPC into RESTful JSON APIs.
|
||||
*/
|
||||
package nodev1
|
||||
|
||||
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_NodePrivilegedService_InjectGovernanceVAA_0(ctx context.Context, marshaler runtime.Marshaler, client NodePrivilegedServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq InjectGovernanceVAARequest
|
||||
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.InjectGovernanceVAA(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_NodePrivilegedService_InjectGovernanceVAA_0(ctx context.Context, marshaler runtime.Marshaler, server NodePrivilegedServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq InjectGovernanceVAARequest
|
||||
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.InjectGovernanceVAA(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_NodePrivilegedService_FindMissingMessages_0(ctx context.Context, marshaler runtime.Marshaler, client NodePrivilegedServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq FindMissingMessagesRequest
|
||||
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.FindMissingMessages(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_NodePrivilegedService_FindMissingMessages_0(ctx context.Context, marshaler runtime.Marshaler, server NodePrivilegedServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq FindMissingMessagesRequest
|
||||
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.FindMissingMessages(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_NodePrivilegedService_SendObservationRequest_0(ctx context.Context, marshaler runtime.Marshaler, client NodePrivilegedServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq SendObservationRequestRequest
|
||||
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.SendObservationRequest(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_NodePrivilegedService_SendObservationRequest_0(ctx context.Context, marshaler runtime.Marshaler, server NodePrivilegedServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq SendObservationRequestRequest
|
||||
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.SendObservationRequest(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_NodePrivilegedService_ChainGovernorStatus_0(ctx context.Context, marshaler runtime.Marshaler, client NodePrivilegedServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq ChainGovernorStatusRequest
|
||||
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.ChainGovernorStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_NodePrivilegedService_ChainGovernorStatus_0(ctx context.Context, marshaler runtime.Marshaler, server NodePrivilegedServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq ChainGovernorStatusRequest
|
||||
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.ChainGovernorStatus(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_NodePrivilegedService_ChainGovernorReload_0(ctx context.Context, marshaler runtime.Marshaler, client NodePrivilegedServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq ChainGovernorReloadRequest
|
||||
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.ChainGovernorReload(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_NodePrivilegedService_ChainGovernorReload_0(ctx context.Context, marshaler runtime.Marshaler, server NodePrivilegedServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq ChainGovernorReloadRequest
|
||||
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.ChainGovernorReload(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_NodePrivilegedService_ChainGovernorDropPendingVAA_0(ctx context.Context, marshaler runtime.Marshaler, client NodePrivilegedServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq ChainGovernorDropPendingVAARequest
|
||||
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.ChainGovernorDropPendingVAA(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_NodePrivilegedService_ChainGovernorDropPendingVAA_0(ctx context.Context, marshaler runtime.Marshaler, server NodePrivilegedServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq ChainGovernorDropPendingVAARequest
|
||||
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.ChainGovernorDropPendingVAA(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_NodePrivilegedService_ChainGovernorReleasePendingVAA_0(ctx context.Context, marshaler runtime.Marshaler, client NodePrivilegedServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq ChainGovernorReleasePendingVAARequest
|
||||
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.ChainGovernorReleasePendingVAA(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_NodePrivilegedService_ChainGovernorReleasePendingVAA_0(ctx context.Context, marshaler runtime.Marshaler, server NodePrivilegedServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq ChainGovernorReleasePendingVAARequest
|
||||
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.ChainGovernorReleasePendingVAA(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_NodePrivilegedService_ChainGovernorResetReleaseTimer_0(ctx context.Context, marshaler runtime.Marshaler, client NodePrivilegedServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq ChainGovernorResetReleaseTimerRequest
|
||||
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.ChainGovernorResetReleaseTimer(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_NodePrivilegedService_ChainGovernorResetReleaseTimer_0(ctx context.Context, marshaler runtime.Marshaler, server NodePrivilegedServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq ChainGovernorResetReleaseTimerRequest
|
||||
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.ChainGovernorResetReleaseTimer(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_NodePrivilegedService_PurgePythNetVaas_0(ctx context.Context, marshaler runtime.Marshaler, client NodePrivilegedServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq PurgePythNetVaasRequest
|
||||
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.PurgePythNetVaas(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_NodePrivilegedService_PurgePythNetVaas_0(ctx context.Context, marshaler runtime.Marshaler, server NodePrivilegedServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq PurgePythNetVaasRequest
|
||||
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.PurgePythNetVaas(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_NodePrivilegedService_SignExistingVAA_0(ctx context.Context, marshaler runtime.Marshaler, client NodePrivilegedServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq SignExistingVAARequest
|
||||
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.SignExistingVAA(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_NodePrivilegedService_SignExistingVAA_0(ctx context.Context, marshaler runtime.Marshaler, server NodePrivilegedServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq SignExistingVAARequest
|
||||
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.SignExistingVAA(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_NodePrivilegedService_DumpRPCs_0(ctx context.Context, marshaler runtime.Marshaler, client NodePrivilegedServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq DumpRPCsRequest
|
||||
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.DumpRPCs(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_NodePrivilegedService_DumpRPCs_0(ctx context.Context, marshaler runtime.Marshaler, server NodePrivilegedServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq DumpRPCsRequest
|
||||
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.DumpRPCs(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
// RegisterNodePrivilegedServiceHandlerServer registers the http handlers for service NodePrivilegedService to "mux".
|
||||
// UnaryRPC :call NodePrivilegedServiceServer 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 RegisterNodePrivilegedServiceHandlerFromEndpoint instead.
|
||||
func RegisterNodePrivilegedServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server NodePrivilegedServiceServer) error {
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_InjectGovernanceVAA_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, "/node.v1.NodePrivilegedService/InjectGovernanceVAA", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/InjectGovernanceVAA"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_NodePrivilegedService_InjectGovernanceVAA_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_NodePrivilegedService_InjectGovernanceVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_FindMissingMessages_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, "/node.v1.NodePrivilegedService/FindMissingMessages", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/FindMissingMessages"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_NodePrivilegedService_FindMissingMessages_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_NodePrivilegedService_FindMissingMessages_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_SendObservationRequest_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, "/node.v1.NodePrivilegedService/SendObservationRequest", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/SendObservationRequest"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_NodePrivilegedService_SendObservationRequest_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_NodePrivilegedService_SendObservationRequest_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_ChainGovernorStatus_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, "/node.v1.NodePrivilegedService/ChainGovernorStatus", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/ChainGovernorStatus"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_NodePrivilegedService_ChainGovernorStatus_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_NodePrivilegedService_ChainGovernorStatus_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_ChainGovernorReload_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, "/node.v1.NodePrivilegedService/ChainGovernorReload", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/ChainGovernorReload"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_NodePrivilegedService_ChainGovernorReload_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_NodePrivilegedService_ChainGovernorReload_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_ChainGovernorDropPendingVAA_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, "/node.v1.NodePrivilegedService/ChainGovernorDropPendingVAA", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/ChainGovernorDropPendingVAA"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_NodePrivilegedService_ChainGovernorDropPendingVAA_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_NodePrivilegedService_ChainGovernorDropPendingVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_ChainGovernorReleasePendingVAA_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, "/node.v1.NodePrivilegedService/ChainGovernorReleasePendingVAA", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/ChainGovernorReleasePendingVAA"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_NodePrivilegedService_ChainGovernorReleasePendingVAA_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_NodePrivilegedService_ChainGovernorReleasePendingVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_ChainGovernorResetReleaseTimer_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, "/node.v1.NodePrivilegedService/ChainGovernorResetReleaseTimer", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/ChainGovernorResetReleaseTimer"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_NodePrivilegedService_ChainGovernorResetReleaseTimer_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_NodePrivilegedService_ChainGovernorResetReleaseTimer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_PurgePythNetVaas_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, "/node.v1.NodePrivilegedService/PurgePythNetVaas", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/PurgePythNetVaas"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_NodePrivilegedService_PurgePythNetVaas_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_NodePrivilegedService_PurgePythNetVaas_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_SignExistingVAA_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, "/node.v1.NodePrivilegedService/SignExistingVAA", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/SignExistingVAA"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_NodePrivilegedService_SignExistingVAA_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_NodePrivilegedService_SignExistingVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_DumpRPCs_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, "/node.v1.NodePrivilegedService/DumpRPCs", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/DumpRPCs"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_NodePrivilegedService_DumpRPCs_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_NodePrivilegedService_DumpRPCs_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// RegisterNodePrivilegedServiceHandlerFromEndpoint is same as RegisterNodePrivilegedServiceHandler but
|
||||
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
|
||||
func RegisterNodePrivilegedServiceHandlerFromEndpoint(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 RegisterNodePrivilegedServiceHandler(ctx, mux, conn)
|
||||
}
|
||||
|
||||
// RegisterNodePrivilegedServiceHandler registers the http handlers for service NodePrivilegedService to "mux".
|
||||
// The handlers forward requests to the grpc endpoint over "conn".
|
||||
func RegisterNodePrivilegedServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
|
||||
return RegisterNodePrivilegedServiceHandlerClient(ctx, mux, NewNodePrivilegedServiceClient(conn))
|
||||
}
|
||||
|
||||
// RegisterNodePrivilegedServiceHandlerClient registers the http handlers for service NodePrivilegedService
|
||||
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NodePrivilegedServiceClient".
|
||||
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NodePrivilegedServiceClient"
|
||||
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
|
||||
// "NodePrivilegedServiceClient" to call the correct interceptors.
|
||||
func RegisterNodePrivilegedServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NodePrivilegedServiceClient) error {
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_InjectGovernanceVAA_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, "/node.v1.NodePrivilegedService/InjectGovernanceVAA", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/InjectGovernanceVAA"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_NodePrivilegedService_InjectGovernanceVAA_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_NodePrivilegedService_InjectGovernanceVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_FindMissingMessages_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, "/node.v1.NodePrivilegedService/FindMissingMessages", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/FindMissingMessages"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_NodePrivilegedService_FindMissingMessages_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_NodePrivilegedService_FindMissingMessages_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_SendObservationRequest_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, "/node.v1.NodePrivilegedService/SendObservationRequest", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/SendObservationRequest"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_NodePrivilegedService_SendObservationRequest_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_NodePrivilegedService_SendObservationRequest_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_ChainGovernorStatus_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, "/node.v1.NodePrivilegedService/ChainGovernorStatus", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/ChainGovernorStatus"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_NodePrivilegedService_ChainGovernorStatus_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_NodePrivilegedService_ChainGovernorStatus_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_ChainGovernorReload_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, "/node.v1.NodePrivilegedService/ChainGovernorReload", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/ChainGovernorReload"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_NodePrivilegedService_ChainGovernorReload_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_NodePrivilegedService_ChainGovernorReload_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_ChainGovernorDropPendingVAA_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, "/node.v1.NodePrivilegedService/ChainGovernorDropPendingVAA", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/ChainGovernorDropPendingVAA"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_NodePrivilegedService_ChainGovernorDropPendingVAA_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_NodePrivilegedService_ChainGovernorDropPendingVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_ChainGovernorReleasePendingVAA_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, "/node.v1.NodePrivilegedService/ChainGovernorReleasePendingVAA", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/ChainGovernorReleasePendingVAA"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_NodePrivilegedService_ChainGovernorReleasePendingVAA_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_NodePrivilegedService_ChainGovernorReleasePendingVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_ChainGovernorResetReleaseTimer_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, "/node.v1.NodePrivilegedService/ChainGovernorResetReleaseTimer", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/ChainGovernorResetReleaseTimer"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_NodePrivilegedService_ChainGovernorResetReleaseTimer_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_NodePrivilegedService_ChainGovernorResetReleaseTimer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_PurgePythNetVaas_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, "/node.v1.NodePrivilegedService/PurgePythNetVaas", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/PurgePythNetVaas"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_NodePrivilegedService_PurgePythNetVaas_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_NodePrivilegedService_PurgePythNetVaas_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_SignExistingVAA_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, "/node.v1.NodePrivilegedService/SignExistingVAA", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/SignExistingVAA"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_NodePrivilegedService_SignExistingVAA_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_NodePrivilegedService_SignExistingVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_NodePrivilegedService_DumpRPCs_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, "/node.v1.NodePrivilegedService/DumpRPCs", runtime.WithHTTPPathPattern("/node.v1.NodePrivilegedService/DumpRPCs"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_NodePrivilegedService_DumpRPCs_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_NodePrivilegedService_DumpRPCs_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
var (
|
||||
pattern_NodePrivilegedService_InjectGovernanceVAA_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"node.v1.NodePrivilegedService", "InjectGovernanceVAA"}, ""))
|
||||
|
||||
pattern_NodePrivilegedService_FindMissingMessages_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"node.v1.NodePrivilegedService", "FindMissingMessages"}, ""))
|
||||
|
||||
pattern_NodePrivilegedService_SendObservationRequest_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"node.v1.NodePrivilegedService", "SendObservationRequest"}, ""))
|
||||
|
||||
pattern_NodePrivilegedService_ChainGovernorStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"node.v1.NodePrivilegedService", "ChainGovernorStatus"}, ""))
|
||||
|
||||
pattern_NodePrivilegedService_ChainGovernorReload_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"node.v1.NodePrivilegedService", "ChainGovernorReload"}, ""))
|
||||
|
||||
pattern_NodePrivilegedService_ChainGovernorDropPendingVAA_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"node.v1.NodePrivilegedService", "ChainGovernorDropPendingVAA"}, ""))
|
||||
|
||||
pattern_NodePrivilegedService_ChainGovernorReleasePendingVAA_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"node.v1.NodePrivilegedService", "ChainGovernorReleasePendingVAA"}, ""))
|
||||
|
||||
pattern_NodePrivilegedService_ChainGovernorResetReleaseTimer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"node.v1.NodePrivilegedService", "ChainGovernorResetReleaseTimer"}, ""))
|
||||
|
||||
pattern_NodePrivilegedService_PurgePythNetVaas_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"node.v1.NodePrivilegedService", "PurgePythNetVaas"}, ""))
|
||||
|
||||
pattern_NodePrivilegedService_SignExistingVAA_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"node.v1.NodePrivilegedService", "SignExistingVAA"}, ""))
|
||||
|
||||
pattern_NodePrivilegedService_DumpRPCs_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"node.v1.NodePrivilegedService", "DumpRPCs"}, ""))
|
||||
)
|
||||
|
||||
var (
|
||||
forward_NodePrivilegedService_InjectGovernanceVAA_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_NodePrivilegedService_FindMissingMessages_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_NodePrivilegedService_SendObservationRequest_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_NodePrivilegedService_ChainGovernorStatus_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_NodePrivilegedService_ChainGovernorReload_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_NodePrivilegedService_ChainGovernorDropPendingVAA_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_NodePrivilegedService_ChainGovernorReleasePendingVAA_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_NodePrivilegedService_ChainGovernorResetReleaseTimer_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_NodePrivilegedService_PurgePythNetVaas_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_NodePrivilegedService_SignExistingVAA_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_NodePrivilegedService_DumpRPCs_0 = runtime.ForwardResponseMessage
|
||||
)
|
|
@ -0,0 +1,503 @@
|
|||
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
||||
|
||||
package nodev1
|
||||
|
||||
import (
|
||||
context "context"
|
||||
grpc "google.golang.org/grpc"
|
||||
codes "google.golang.org/grpc/codes"
|
||||
status "google.golang.org/grpc/status"
|
||||
)
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file
|
||||
// is compatible with the grpc package it is being compiled against.
|
||||
// Requires gRPC-Go v1.32.0 or later.
|
||||
const _ = grpc.SupportPackageIsVersion7
|
||||
|
||||
// NodePrivilegedServiceClient is the client API for NodePrivilegedService service.
|
||||
//
|
||||
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
||||
type NodePrivilegedServiceClient interface {
|
||||
// InjectGovernanceVAA injects a governance VAA into the guardian node.
|
||||
// The node will inject the VAA into the aggregator and sign/broadcast the VAA signature.
|
||||
//
|
||||
// A consensus majority of nodes on the network will have to inject the VAA within the
|
||||
// VAA timeout window for it to reach consensus.
|
||||
InjectGovernanceVAA(ctx context.Context, in *InjectGovernanceVAARequest, opts ...grpc.CallOption) (*InjectGovernanceVAAResponse, error)
|
||||
// FindMissingMessages will detect message sequence gaps in the local VAA store for a
|
||||
// specific emitter chain and address. Start and end slots are the lowest and highest
|
||||
// sequence numbers available in the local store, respectively.
|
||||
//
|
||||
// An error is returned if more than 1000 gaps are found.
|
||||
FindMissingMessages(ctx context.Context, in *FindMissingMessagesRequest, opts ...grpc.CallOption) (*FindMissingMessagesResponse, error)
|
||||
// SendObservationRequest broadcasts a signed observation request to the gossip network
|
||||
// using the node's guardian key. The network rate limits these requests to one per second.
|
||||
// Requests at higher rates will fail silently.
|
||||
SendObservationRequest(ctx context.Context, in *SendObservationRequestRequest, opts ...grpc.CallOption) (*SendObservationRequestResponse, error)
|
||||
// ChainGovernorStatus displays the status of the chain governor.
|
||||
ChainGovernorStatus(ctx context.Context, in *ChainGovernorStatusRequest, opts ...grpc.CallOption) (*ChainGovernorStatusResponse, error)
|
||||
// ChainGovernorReload clears the chain governor history and reloads it from the database.
|
||||
ChainGovernorReload(ctx context.Context, in *ChainGovernorReloadRequest, opts ...grpc.CallOption) (*ChainGovernorReloadResponse, error)
|
||||
// ChainGovernorDropPendingVAA drops a VAA from the chain governor pending list.
|
||||
ChainGovernorDropPendingVAA(ctx context.Context, in *ChainGovernorDropPendingVAARequest, opts ...grpc.CallOption) (*ChainGovernorDropPendingVAAResponse, error)
|
||||
// ChainGovernorReleasePendingVAA release a VAA from the chain governor pending list, publishing it immediately.
|
||||
ChainGovernorReleasePendingVAA(ctx context.Context, in *ChainGovernorReleasePendingVAARequest, opts ...grpc.CallOption) (*ChainGovernorReleasePendingVAAResponse, error)
|
||||
// ChainGovernorResetReleaseTimer resets the release timer for a chain governor pending VAA to the configured maximum.
|
||||
ChainGovernorResetReleaseTimer(ctx context.Context, in *ChainGovernorResetReleaseTimerRequest, opts ...grpc.CallOption) (*ChainGovernorResetReleaseTimerResponse, error)
|
||||
// PurgePythNetVaas deletes PythNet VAAs from the database that are more than the specified number of days old.
|
||||
PurgePythNetVaas(ctx context.Context, in *PurgePythNetVaasRequest, opts ...grpc.CallOption) (*PurgePythNetVaasResponse, error)
|
||||
// SignExistingVAA signs an existing VAA for a new guardian set using the local guardian key.
|
||||
SignExistingVAA(ctx context.Context, in *SignExistingVAARequest, opts ...grpc.CallOption) (*SignExistingVAAResponse, error)
|
||||
// DumpRPCs returns the RPCs being used by the guardian
|
||||
DumpRPCs(ctx context.Context, in *DumpRPCsRequest, opts ...grpc.CallOption) (*DumpRPCsResponse, error)
|
||||
}
|
||||
|
||||
type nodePrivilegedServiceClient struct {
|
||||
cc grpc.ClientConnInterface
|
||||
}
|
||||
|
||||
func NewNodePrivilegedServiceClient(cc grpc.ClientConnInterface) NodePrivilegedServiceClient {
|
||||
return &nodePrivilegedServiceClient{cc}
|
||||
}
|
||||
|
||||
func (c *nodePrivilegedServiceClient) InjectGovernanceVAA(ctx context.Context, in *InjectGovernanceVAARequest, opts ...grpc.CallOption) (*InjectGovernanceVAAResponse, error) {
|
||||
out := new(InjectGovernanceVAAResponse)
|
||||
err := c.cc.Invoke(ctx, "/node.v1.NodePrivilegedService/InjectGovernanceVAA", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *nodePrivilegedServiceClient) FindMissingMessages(ctx context.Context, in *FindMissingMessagesRequest, opts ...grpc.CallOption) (*FindMissingMessagesResponse, error) {
|
||||
out := new(FindMissingMessagesResponse)
|
||||
err := c.cc.Invoke(ctx, "/node.v1.NodePrivilegedService/FindMissingMessages", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *nodePrivilegedServiceClient) SendObservationRequest(ctx context.Context, in *SendObservationRequestRequest, opts ...grpc.CallOption) (*SendObservationRequestResponse, error) {
|
||||
out := new(SendObservationRequestResponse)
|
||||
err := c.cc.Invoke(ctx, "/node.v1.NodePrivilegedService/SendObservationRequest", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *nodePrivilegedServiceClient) ChainGovernorStatus(ctx context.Context, in *ChainGovernorStatusRequest, opts ...grpc.CallOption) (*ChainGovernorStatusResponse, error) {
|
||||
out := new(ChainGovernorStatusResponse)
|
||||
err := c.cc.Invoke(ctx, "/node.v1.NodePrivilegedService/ChainGovernorStatus", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *nodePrivilegedServiceClient) ChainGovernorReload(ctx context.Context, in *ChainGovernorReloadRequest, opts ...grpc.CallOption) (*ChainGovernorReloadResponse, error) {
|
||||
out := new(ChainGovernorReloadResponse)
|
||||
err := c.cc.Invoke(ctx, "/node.v1.NodePrivilegedService/ChainGovernorReload", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *nodePrivilegedServiceClient) ChainGovernorDropPendingVAA(ctx context.Context, in *ChainGovernorDropPendingVAARequest, opts ...grpc.CallOption) (*ChainGovernorDropPendingVAAResponse, error) {
|
||||
out := new(ChainGovernorDropPendingVAAResponse)
|
||||
err := c.cc.Invoke(ctx, "/node.v1.NodePrivilegedService/ChainGovernorDropPendingVAA", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *nodePrivilegedServiceClient) ChainGovernorReleasePendingVAA(ctx context.Context, in *ChainGovernorReleasePendingVAARequest, opts ...grpc.CallOption) (*ChainGovernorReleasePendingVAAResponse, error) {
|
||||
out := new(ChainGovernorReleasePendingVAAResponse)
|
||||
err := c.cc.Invoke(ctx, "/node.v1.NodePrivilegedService/ChainGovernorReleasePendingVAA", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *nodePrivilegedServiceClient) ChainGovernorResetReleaseTimer(ctx context.Context, in *ChainGovernorResetReleaseTimerRequest, opts ...grpc.CallOption) (*ChainGovernorResetReleaseTimerResponse, error) {
|
||||
out := new(ChainGovernorResetReleaseTimerResponse)
|
||||
err := c.cc.Invoke(ctx, "/node.v1.NodePrivilegedService/ChainGovernorResetReleaseTimer", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *nodePrivilegedServiceClient) PurgePythNetVaas(ctx context.Context, in *PurgePythNetVaasRequest, opts ...grpc.CallOption) (*PurgePythNetVaasResponse, error) {
|
||||
out := new(PurgePythNetVaasResponse)
|
||||
err := c.cc.Invoke(ctx, "/node.v1.NodePrivilegedService/PurgePythNetVaas", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *nodePrivilegedServiceClient) SignExistingVAA(ctx context.Context, in *SignExistingVAARequest, opts ...grpc.CallOption) (*SignExistingVAAResponse, error) {
|
||||
out := new(SignExistingVAAResponse)
|
||||
err := c.cc.Invoke(ctx, "/node.v1.NodePrivilegedService/SignExistingVAA", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *nodePrivilegedServiceClient) DumpRPCs(ctx context.Context, in *DumpRPCsRequest, opts ...grpc.CallOption) (*DumpRPCsResponse, error) {
|
||||
out := new(DumpRPCsResponse)
|
||||
err := c.cc.Invoke(ctx, "/node.v1.NodePrivilegedService/DumpRPCs", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// NodePrivilegedServiceServer is the server API for NodePrivilegedService service.
|
||||
// All implementations must embed UnimplementedNodePrivilegedServiceServer
|
||||
// for forward compatibility
|
||||
type NodePrivilegedServiceServer interface {
|
||||
// InjectGovernanceVAA injects a governance VAA into the guardian node.
|
||||
// The node will inject the VAA into the aggregator and sign/broadcast the VAA signature.
|
||||
//
|
||||
// A consensus majority of nodes on the network will have to inject the VAA within the
|
||||
// VAA timeout window for it to reach consensus.
|
||||
InjectGovernanceVAA(context.Context, *InjectGovernanceVAARequest) (*InjectGovernanceVAAResponse, error)
|
||||
// FindMissingMessages will detect message sequence gaps in the local VAA store for a
|
||||
// specific emitter chain and address. Start and end slots are the lowest and highest
|
||||
// sequence numbers available in the local store, respectively.
|
||||
//
|
||||
// An error is returned if more than 1000 gaps are found.
|
||||
FindMissingMessages(context.Context, *FindMissingMessagesRequest) (*FindMissingMessagesResponse, error)
|
||||
// SendObservationRequest broadcasts a signed observation request to the gossip network
|
||||
// using the node's guardian key. The network rate limits these requests to one per second.
|
||||
// Requests at higher rates will fail silently.
|
||||
SendObservationRequest(context.Context, *SendObservationRequestRequest) (*SendObservationRequestResponse, error)
|
||||
// ChainGovernorStatus displays the status of the chain governor.
|
||||
ChainGovernorStatus(context.Context, *ChainGovernorStatusRequest) (*ChainGovernorStatusResponse, error)
|
||||
// ChainGovernorReload clears the chain governor history and reloads it from the database.
|
||||
ChainGovernorReload(context.Context, *ChainGovernorReloadRequest) (*ChainGovernorReloadResponse, error)
|
||||
// ChainGovernorDropPendingVAA drops a VAA from the chain governor pending list.
|
||||
ChainGovernorDropPendingVAA(context.Context, *ChainGovernorDropPendingVAARequest) (*ChainGovernorDropPendingVAAResponse, error)
|
||||
// ChainGovernorReleasePendingVAA release a VAA from the chain governor pending list, publishing it immediately.
|
||||
ChainGovernorReleasePendingVAA(context.Context, *ChainGovernorReleasePendingVAARequest) (*ChainGovernorReleasePendingVAAResponse, error)
|
||||
// ChainGovernorResetReleaseTimer resets the release timer for a chain governor pending VAA to the configured maximum.
|
||||
ChainGovernorResetReleaseTimer(context.Context, *ChainGovernorResetReleaseTimerRequest) (*ChainGovernorResetReleaseTimerResponse, error)
|
||||
// PurgePythNetVaas deletes PythNet VAAs from the database that are more than the specified number of days old.
|
||||
PurgePythNetVaas(context.Context, *PurgePythNetVaasRequest) (*PurgePythNetVaasResponse, error)
|
||||
// SignExistingVAA signs an existing VAA for a new guardian set using the local guardian key.
|
||||
SignExistingVAA(context.Context, *SignExistingVAARequest) (*SignExistingVAAResponse, error)
|
||||
// DumpRPCs returns the RPCs being used by the guardian
|
||||
DumpRPCs(context.Context, *DumpRPCsRequest) (*DumpRPCsResponse, error)
|
||||
mustEmbedUnimplementedNodePrivilegedServiceServer()
|
||||
}
|
||||
|
||||
// UnimplementedNodePrivilegedServiceServer must be embedded to have forward compatible implementations.
|
||||
type UnimplementedNodePrivilegedServiceServer struct {
|
||||
}
|
||||
|
||||
func (UnimplementedNodePrivilegedServiceServer) InjectGovernanceVAA(context.Context, *InjectGovernanceVAARequest) (*InjectGovernanceVAAResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method InjectGovernanceVAA not implemented")
|
||||
}
|
||||
func (UnimplementedNodePrivilegedServiceServer) FindMissingMessages(context.Context, *FindMissingMessagesRequest) (*FindMissingMessagesResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method FindMissingMessages not implemented")
|
||||
}
|
||||
func (UnimplementedNodePrivilegedServiceServer) SendObservationRequest(context.Context, *SendObservationRequestRequest) (*SendObservationRequestResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method SendObservationRequest not implemented")
|
||||
}
|
||||
func (UnimplementedNodePrivilegedServiceServer) ChainGovernorStatus(context.Context, *ChainGovernorStatusRequest) (*ChainGovernorStatusResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method ChainGovernorStatus not implemented")
|
||||
}
|
||||
func (UnimplementedNodePrivilegedServiceServer) ChainGovernorReload(context.Context, *ChainGovernorReloadRequest) (*ChainGovernorReloadResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method ChainGovernorReload not implemented")
|
||||
}
|
||||
func (UnimplementedNodePrivilegedServiceServer) ChainGovernorDropPendingVAA(context.Context, *ChainGovernorDropPendingVAARequest) (*ChainGovernorDropPendingVAAResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method ChainGovernorDropPendingVAA not implemented")
|
||||
}
|
||||
func (UnimplementedNodePrivilegedServiceServer) ChainGovernorReleasePendingVAA(context.Context, *ChainGovernorReleasePendingVAARequest) (*ChainGovernorReleasePendingVAAResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method ChainGovernorReleasePendingVAA not implemented")
|
||||
}
|
||||
func (UnimplementedNodePrivilegedServiceServer) ChainGovernorResetReleaseTimer(context.Context, *ChainGovernorResetReleaseTimerRequest) (*ChainGovernorResetReleaseTimerResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method ChainGovernorResetReleaseTimer not implemented")
|
||||
}
|
||||
func (UnimplementedNodePrivilegedServiceServer) PurgePythNetVaas(context.Context, *PurgePythNetVaasRequest) (*PurgePythNetVaasResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method PurgePythNetVaas not implemented")
|
||||
}
|
||||
func (UnimplementedNodePrivilegedServiceServer) SignExistingVAA(context.Context, *SignExistingVAARequest) (*SignExistingVAAResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method SignExistingVAA not implemented")
|
||||
}
|
||||
func (UnimplementedNodePrivilegedServiceServer) DumpRPCs(context.Context, *DumpRPCsRequest) (*DumpRPCsResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method DumpRPCs not implemented")
|
||||
}
|
||||
func (UnimplementedNodePrivilegedServiceServer) mustEmbedUnimplementedNodePrivilegedServiceServer() {}
|
||||
|
||||
// UnsafeNodePrivilegedServiceServer may be embedded to opt out of forward compatibility for this service.
|
||||
// Use of this interface is not recommended, as added methods to NodePrivilegedServiceServer will
|
||||
// result in compilation errors.
|
||||
type UnsafeNodePrivilegedServiceServer interface {
|
||||
mustEmbedUnimplementedNodePrivilegedServiceServer()
|
||||
}
|
||||
|
||||
func RegisterNodePrivilegedServiceServer(s grpc.ServiceRegistrar, srv NodePrivilegedServiceServer) {
|
||||
s.RegisterService(&NodePrivilegedService_ServiceDesc, srv)
|
||||
}
|
||||
|
||||
func _NodePrivilegedService_InjectGovernanceVAA_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(InjectGovernanceVAARequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(NodePrivilegedServiceServer).InjectGovernanceVAA(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/node.v1.NodePrivilegedService/InjectGovernanceVAA",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(NodePrivilegedServiceServer).InjectGovernanceVAA(ctx, req.(*InjectGovernanceVAARequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _NodePrivilegedService_FindMissingMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(FindMissingMessagesRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(NodePrivilegedServiceServer).FindMissingMessages(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/node.v1.NodePrivilegedService/FindMissingMessages",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(NodePrivilegedServiceServer).FindMissingMessages(ctx, req.(*FindMissingMessagesRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _NodePrivilegedService_SendObservationRequest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(SendObservationRequestRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(NodePrivilegedServiceServer).SendObservationRequest(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/node.v1.NodePrivilegedService/SendObservationRequest",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(NodePrivilegedServiceServer).SendObservationRequest(ctx, req.(*SendObservationRequestRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _NodePrivilegedService_ChainGovernorStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(ChainGovernorStatusRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(NodePrivilegedServiceServer).ChainGovernorStatus(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/node.v1.NodePrivilegedService/ChainGovernorStatus",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(NodePrivilegedServiceServer).ChainGovernorStatus(ctx, req.(*ChainGovernorStatusRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _NodePrivilegedService_ChainGovernorReload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(ChainGovernorReloadRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(NodePrivilegedServiceServer).ChainGovernorReload(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/node.v1.NodePrivilegedService/ChainGovernorReload",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(NodePrivilegedServiceServer).ChainGovernorReload(ctx, req.(*ChainGovernorReloadRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _NodePrivilegedService_ChainGovernorDropPendingVAA_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(ChainGovernorDropPendingVAARequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(NodePrivilegedServiceServer).ChainGovernorDropPendingVAA(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/node.v1.NodePrivilegedService/ChainGovernorDropPendingVAA",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(NodePrivilegedServiceServer).ChainGovernorDropPendingVAA(ctx, req.(*ChainGovernorDropPendingVAARequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _NodePrivilegedService_ChainGovernorReleasePendingVAA_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(ChainGovernorReleasePendingVAARequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(NodePrivilegedServiceServer).ChainGovernorReleasePendingVAA(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/node.v1.NodePrivilegedService/ChainGovernorReleasePendingVAA",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(NodePrivilegedServiceServer).ChainGovernorReleasePendingVAA(ctx, req.(*ChainGovernorReleasePendingVAARequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _NodePrivilegedService_ChainGovernorResetReleaseTimer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(ChainGovernorResetReleaseTimerRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(NodePrivilegedServiceServer).ChainGovernorResetReleaseTimer(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/node.v1.NodePrivilegedService/ChainGovernorResetReleaseTimer",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(NodePrivilegedServiceServer).ChainGovernorResetReleaseTimer(ctx, req.(*ChainGovernorResetReleaseTimerRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _NodePrivilegedService_PurgePythNetVaas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(PurgePythNetVaasRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(NodePrivilegedServiceServer).PurgePythNetVaas(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/node.v1.NodePrivilegedService/PurgePythNetVaas",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(NodePrivilegedServiceServer).PurgePythNetVaas(ctx, req.(*PurgePythNetVaasRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _NodePrivilegedService_SignExistingVAA_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(SignExistingVAARequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(NodePrivilegedServiceServer).SignExistingVAA(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/node.v1.NodePrivilegedService/SignExistingVAA",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(NodePrivilegedServiceServer).SignExistingVAA(ctx, req.(*SignExistingVAARequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _NodePrivilegedService_DumpRPCs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(DumpRPCsRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(NodePrivilegedServiceServer).DumpRPCs(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/node.v1.NodePrivilegedService/DumpRPCs",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(NodePrivilegedServiceServer).DumpRPCs(ctx, req.(*DumpRPCsRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
// NodePrivilegedService_ServiceDesc is the grpc.ServiceDesc for NodePrivilegedService service.
|
||||
// It's only intended for direct use with grpc.RegisterService,
|
||||
// and not to be introspected or modified (even as a copy)
|
||||
var NodePrivilegedService_ServiceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "node.v1.NodePrivilegedService",
|
||||
HandlerType: (*NodePrivilegedServiceServer)(nil),
|
||||
Methods: []grpc.MethodDesc{
|
||||
{
|
||||
MethodName: "InjectGovernanceVAA",
|
||||
Handler: _NodePrivilegedService_InjectGovernanceVAA_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "FindMissingMessages",
|
||||
Handler: _NodePrivilegedService_FindMissingMessages_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "SendObservationRequest",
|
||||
Handler: _NodePrivilegedService_SendObservationRequest_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "ChainGovernorStatus",
|
||||
Handler: _NodePrivilegedService_ChainGovernorStatus_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "ChainGovernorReload",
|
||||
Handler: _NodePrivilegedService_ChainGovernorReload_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "ChainGovernorDropPendingVAA",
|
||||
Handler: _NodePrivilegedService_ChainGovernorDropPendingVAA_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "ChainGovernorReleasePendingVAA",
|
||||
Handler: _NodePrivilegedService_ChainGovernorReleasePendingVAA_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "ChainGovernorResetReleaseTimer",
|
||||
Handler: _NodePrivilegedService_ChainGovernorResetReleaseTimer_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "PurgePythNetVaas",
|
||||
Handler: _NodePrivilegedService_PurgePythNetVaas_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "SignExistingVAA",
|
||||
Handler: _NodePrivilegedService_SignExistingVAA_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "DumpRPCs",
|
||||
Handler: _NodePrivilegedService_DumpRPCs_Handler,
|
||||
},
|
||||
},
|
||||
Streams: []grpc.StreamDesc{},
|
||||
Metadata: "node/v1/node.proto",
|
||||
}
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,930 @@
|
|||
// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
|
||||
// source: publicrpc/v1/publicrpc.proto
|
||||
|
||||
/*
|
||||
Package publicrpcv1 is a reverse proxy.
|
||||
|
||||
It translates gRPC into RESTful JSON APIs.
|
||||
*/
|
||||
package publicrpcv1
|
||||
|
||||
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_PublicRPCService_GetLastHeartbeats_0(ctx context.Context, marshaler runtime.Marshaler, client PublicRPCServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GetLastHeartbeatsRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
msg, err := client.GetLastHeartbeats(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_PublicRPCService_GetLastHeartbeats_0(ctx context.Context, marshaler runtime.Marshaler, server PublicRPCServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GetLastHeartbeatsRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
msg, err := server.GetLastHeartbeats(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
var (
|
||||
filter_PublicRPCService_GetSignedVAA_0 = &utilities.DoubleArray{Encoding: map[string]int{"message_id": 0, "emitter_chain": 1, "emitter_address": 2, "sequence": 3}, Base: []int{1, 1, 1, 2, 3, 0, 0, 0}, Check: []int{0, 1, 2, 2, 2, 3, 4, 5}}
|
||||
)
|
||||
|
||||
func request_PublicRPCService_GetSignedVAA_0(ctx context.Context, marshaler runtime.Marshaler, client PublicRPCServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GetSignedVAARequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
var (
|
||||
val string
|
||||
e int32
|
||||
ok bool
|
||||
err error
|
||||
_ = err
|
||||
)
|
||||
|
||||
val, ok = pathParams["message_id.emitter_chain"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.emitter_chain")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.emitter_chain", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
e, err = runtime.Enum(val, ChainID_value)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "could not parse path as enum value, parameter: %s, error: %v", "message_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
protoReq.MessageId.EmitterChain = ChainID(e)
|
||||
|
||||
val, ok = pathParams["message_id.emitter_address"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.emitter_address")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.emitter_address", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.emitter_address", err)
|
||||
}
|
||||
|
||||
val, ok = pathParams["message_id.sequence"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.sequence")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.sequence", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.sequence", err)
|
||||
}
|
||||
|
||||
if err := req.ParseForm(); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_PublicRPCService_GetSignedVAA_0); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
msg, err := client.GetSignedVAA(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_PublicRPCService_GetSignedVAA_0(ctx context.Context, marshaler runtime.Marshaler, server PublicRPCServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GetSignedVAARequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
var (
|
||||
val string
|
||||
e int32
|
||||
ok bool
|
||||
err error
|
||||
_ = err
|
||||
)
|
||||
|
||||
val, ok = pathParams["message_id.emitter_chain"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.emitter_chain")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.emitter_chain", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
e, err = runtime.Enum(val, ChainID_value)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "could not parse path as enum value, parameter: %s, error: %v", "message_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
protoReq.MessageId.EmitterChain = ChainID(e)
|
||||
|
||||
val, ok = pathParams["message_id.emitter_address"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.emitter_address")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.emitter_address", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.emitter_address", err)
|
||||
}
|
||||
|
||||
val, ok = pathParams["message_id.sequence"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.sequence")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.sequence", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.sequence", err)
|
||||
}
|
||||
|
||||
if err := req.ParseForm(); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_PublicRPCService_GetSignedVAA_0); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
msg, err := server.GetSignedVAA(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
var (
|
||||
filter_PublicRPCService_GetSignedBatchVAA_0 = &utilities.DoubleArray{Encoding: map[string]int{"batch_id": 0, "emitter_chain": 1, "tx_id": 2, "nonce": 3}, Base: []int{1, 1, 1, 2, 3, 0, 0, 0}, Check: []int{0, 1, 2, 2, 2, 3, 4, 5}}
|
||||
)
|
||||
|
||||
func request_PublicRPCService_GetSignedBatchVAA_0(ctx context.Context, marshaler runtime.Marshaler, client PublicRPCServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GetSignedBatchVAARequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
var (
|
||||
val string
|
||||
e int32
|
||||
ok bool
|
||||
err error
|
||||
_ = err
|
||||
)
|
||||
|
||||
val, ok = pathParams["batch_id.emitter_chain"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "batch_id.emitter_chain")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "batch_id.emitter_chain", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "batch_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
e, err = runtime.Enum(val, ChainID_value)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "could not parse path as enum value, parameter: %s, error: %v", "batch_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
protoReq.BatchId.EmitterChain = ChainID(e)
|
||||
|
||||
val, ok = pathParams["batch_id.tx_id"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "batch_id.tx_id")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "batch_id.tx_id", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "batch_id.tx_id", err)
|
||||
}
|
||||
|
||||
val, ok = pathParams["batch_id.nonce"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "batch_id.nonce")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "batch_id.nonce", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "batch_id.nonce", err)
|
||||
}
|
||||
|
||||
if err := req.ParseForm(); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_PublicRPCService_GetSignedBatchVAA_0); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
msg, err := client.GetSignedBatchVAA(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_PublicRPCService_GetSignedBatchVAA_0(ctx context.Context, marshaler runtime.Marshaler, server PublicRPCServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GetSignedBatchVAARequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
var (
|
||||
val string
|
||||
e int32
|
||||
ok bool
|
||||
err error
|
||||
_ = err
|
||||
)
|
||||
|
||||
val, ok = pathParams["batch_id.emitter_chain"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "batch_id.emitter_chain")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "batch_id.emitter_chain", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "batch_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
e, err = runtime.Enum(val, ChainID_value)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "could not parse path as enum value, parameter: %s, error: %v", "batch_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
protoReq.BatchId.EmitterChain = ChainID(e)
|
||||
|
||||
val, ok = pathParams["batch_id.tx_id"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "batch_id.tx_id")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "batch_id.tx_id", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "batch_id.tx_id", err)
|
||||
}
|
||||
|
||||
val, ok = pathParams["batch_id.nonce"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "batch_id.nonce")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "batch_id.nonce", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "batch_id.nonce", err)
|
||||
}
|
||||
|
||||
if err := req.ParseForm(); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_PublicRPCService_GetSignedBatchVAA_0); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
msg, err := server.GetSignedBatchVAA(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_PublicRPCService_GetCurrentGuardianSet_0(ctx context.Context, marshaler runtime.Marshaler, client PublicRPCServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GetCurrentGuardianSetRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
msg, err := client.GetCurrentGuardianSet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_PublicRPCService_GetCurrentGuardianSet_0(ctx context.Context, marshaler runtime.Marshaler, server PublicRPCServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GetCurrentGuardianSetRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
msg, err := server.GetCurrentGuardianSet(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_PublicRPCService_GovernorGetAvailableNotionalByChain_0(ctx context.Context, marshaler runtime.Marshaler, client PublicRPCServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GovernorGetAvailableNotionalByChainRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
msg, err := client.GovernorGetAvailableNotionalByChain(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_PublicRPCService_GovernorGetAvailableNotionalByChain_0(ctx context.Context, marshaler runtime.Marshaler, server PublicRPCServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GovernorGetAvailableNotionalByChainRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
msg, err := server.GovernorGetAvailableNotionalByChain(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_PublicRPCService_GovernorGetEnqueuedVAAs_0(ctx context.Context, marshaler runtime.Marshaler, client PublicRPCServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GovernorGetEnqueuedVAAsRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
msg, err := client.GovernorGetEnqueuedVAAs(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_PublicRPCService_GovernorGetEnqueuedVAAs_0(ctx context.Context, marshaler runtime.Marshaler, server PublicRPCServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GovernorGetEnqueuedVAAsRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
msg, err := server.GovernorGetEnqueuedVAAs(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
var (
|
||||
filter_PublicRPCService_GovernorIsVAAEnqueued_0 = &utilities.DoubleArray{Encoding: map[string]int{"message_id": 0, "emitter_chain": 1, "emitter_address": 2, "sequence": 3}, Base: []int{1, 1, 1, 2, 3, 0, 0, 0}, Check: []int{0, 1, 2, 2, 2, 3, 4, 5}}
|
||||
)
|
||||
|
||||
func request_PublicRPCService_GovernorIsVAAEnqueued_0(ctx context.Context, marshaler runtime.Marshaler, client PublicRPCServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GovernorIsVAAEnqueuedRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
var (
|
||||
val string
|
||||
e int32
|
||||
ok bool
|
||||
err error
|
||||
_ = err
|
||||
)
|
||||
|
||||
val, ok = pathParams["message_id.emitter_chain"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.emitter_chain")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.emitter_chain", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
e, err = runtime.Enum(val, ChainID_value)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "could not parse path as enum value, parameter: %s, error: %v", "message_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
protoReq.MessageId.EmitterChain = ChainID(e)
|
||||
|
||||
val, ok = pathParams["message_id.emitter_address"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.emitter_address")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.emitter_address", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.emitter_address", err)
|
||||
}
|
||||
|
||||
val, ok = pathParams["message_id.sequence"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.sequence")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.sequence", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.sequence", err)
|
||||
}
|
||||
|
||||
if err := req.ParseForm(); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_PublicRPCService_GovernorIsVAAEnqueued_0); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
msg, err := client.GovernorIsVAAEnqueued(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_PublicRPCService_GovernorIsVAAEnqueued_0(ctx context.Context, marshaler runtime.Marshaler, server PublicRPCServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GovernorIsVAAEnqueuedRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
var (
|
||||
val string
|
||||
e int32
|
||||
ok bool
|
||||
err error
|
||||
_ = err
|
||||
)
|
||||
|
||||
val, ok = pathParams["message_id.emitter_chain"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.emitter_chain")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.emitter_chain", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
e, err = runtime.Enum(val, ChainID_value)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "could not parse path as enum value, parameter: %s, error: %v", "message_id.emitter_chain", err)
|
||||
}
|
||||
|
||||
protoReq.MessageId.EmitterChain = ChainID(e)
|
||||
|
||||
val, ok = pathParams["message_id.emitter_address"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.emitter_address")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.emitter_address", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.emitter_address", err)
|
||||
}
|
||||
|
||||
val, ok = pathParams["message_id.sequence"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "message_id.sequence")
|
||||
}
|
||||
|
||||
err = runtime.PopulateFieldFromPath(&protoReq, "message_id.sequence", val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "message_id.sequence", err)
|
||||
}
|
||||
|
||||
if err := req.ParseForm(); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_PublicRPCService_GovernorIsVAAEnqueued_0); err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
msg, err := server.GovernorIsVAAEnqueued(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func request_PublicRPCService_GovernorGetTokenList_0(ctx context.Context, marshaler runtime.Marshaler, client PublicRPCServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GovernorGetTokenListRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
msg, err := client.GovernorGetTokenList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
func local_request_PublicRPCService_GovernorGetTokenList_0(ctx context.Context, marshaler runtime.Marshaler, server PublicRPCServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var protoReq GovernorGetTokenListRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
msg, err := server.GovernorGetTokenList(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
|
||||
}
|
||||
|
||||
// RegisterPublicRPCServiceHandlerServer registers the http handlers for service PublicRPCService to "mux".
|
||||
// UnaryRPC :call PublicRPCServiceServer 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 RegisterPublicRPCServiceHandlerFromEndpoint instead.
|
||||
func RegisterPublicRPCServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server PublicRPCServiceServer) error {
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GetLastHeartbeats_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, "/publicrpc.v1.PublicRPCService/GetLastHeartbeats", runtime.WithHTTPPathPattern("/v1/heartbeats"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_PublicRPCService_GetLastHeartbeats_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_PublicRPCService_GetLastHeartbeats_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GetSignedVAA_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, "/publicrpc.v1.PublicRPCService/GetSignedVAA", runtime.WithHTTPPathPattern("/v1/signed_vaa/{message_id.emitter_chain}/{message_id.emitter_address}/{message_id.sequence}"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_PublicRPCService_GetSignedVAA_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_PublicRPCService_GetSignedVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GetSignedBatchVAA_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, "/publicrpc.v1.PublicRPCService/GetSignedBatchVAA", runtime.WithHTTPPathPattern("/v1/signed_batch_vaa/{batch_id.emitter_chain}/{batch_id.tx_id}/{batch_id.nonce}"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_PublicRPCService_GetSignedBatchVAA_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_PublicRPCService_GetSignedBatchVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GetCurrentGuardianSet_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, "/publicrpc.v1.PublicRPCService/GetCurrentGuardianSet", runtime.WithHTTPPathPattern("/v1/guardianset/current"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_PublicRPCService_GetCurrentGuardianSet_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_PublicRPCService_GetCurrentGuardianSet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GovernorGetAvailableNotionalByChain_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, "/publicrpc.v1.PublicRPCService/GovernorGetAvailableNotionalByChain", runtime.WithHTTPPathPattern("/v1/governor/available_notional_by_chain"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_PublicRPCService_GovernorGetAvailableNotionalByChain_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_PublicRPCService_GovernorGetAvailableNotionalByChain_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GovernorGetEnqueuedVAAs_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, "/publicrpc.v1.PublicRPCService/GovernorGetEnqueuedVAAs", runtime.WithHTTPPathPattern("/v1/governor/enqueued_vaas"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_PublicRPCService_GovernorGetEnqueuedVAAs_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_PublicRPCService_GovernorGetEnqueuedVAAs_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GovernorIsVAAEnqueued_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, "/publicrpc.v1.PublicRPCService/GovernorIsVAAEnqueued", runtime.WithHTTPPathPattern("/v1/governor/is_vaa_enqueued/{message_id.emitter_chain}/{message_id.emitter_address}/{message_id.sequence}"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_PublicRPCService_GovernorIsVAAEnqueued_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_PublicRPCService_GovernorIsVAAEnqueued_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GovernorGetTokenList_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, "/publicrpc.v1.PublicRPCService/GovernorGetTokenList", runtime.WithHTTPPathPattern("/v1/governor/token_list"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_PublicRPCService_GovernorGetTokenList_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_PublicRPCService_GovernorGetTokenList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// RegisterPublicRPCServiceHandlerFromEndpoint is same as RegisterPublicRPCServiceHandler but
|
||||
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
|
||||
func RegisterPublicRPCServiceHandlerFromEndpoint(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 RegisterPublicRPCServiceHandler(ctx, mux, conn)
|
||||
}
|
||||
|
||||
// RegisterPublicRPCServiceHandler registers the http handlers for service PublicRPCService to "mux".
|
||||
// The handlers forward requests to the grpc endpoint over "conn".
|
||||
func RegisterPublicRPCServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
|
||||
return RegisterPublicRPCServiceHandlerClient(ctx, mux, NewPublicRPCServiceClient(conn))
|
||||
}
|
||||
|
||||
// RegisterPublicRPCServiceHandlerClient registers the http handlers for service PublicRPCService
|
||||
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "PublicRPCServiceClient".
|
||||
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "PublicRPCServiceClient"
|
||||
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
|
||||
// "PublicRPCServiceClient" to call the correct interceptors.
|
||||
func RegisterPublicRPCServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client PublicRPCServiceClient) error {
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GetLastHeartbeats_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, "/publicrpc.v1.PublicRPCService/GetLastHeartbeats", runtime.WithHTTPPathPattern("/v1/heartbeats"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_PublicRPCService_GetLastHeartbeats_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_PublicRPCService_GetLastHeartbeats_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GetSignedVAA_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, "/publicrpc.v1.PublicRPCService/GetSignedVAA", runtime.WithHTTPPathPattern("/v1/signed_vaa/{message_id.emitter_chain}/{message_id.emitter_address}/{message_id.sequence}"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_PublicRPCService_GetSignedVAA_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_PublicRPCService_GetSignedVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GetSignedBatchVAA_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, "/publicrpc.v1.PublicRPCService/GetSignedBatchVAA", runtime.WithHTTPPathPattern("/v1/signed_batch_vaa/{batch_id.emitter_chain}/{batch_id.tx_id}/{batch_id.nonce}"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_PublicRPCService_GetSignedBatchVAA_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_PublicRPCService_GetSignedBatchVAA_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GetCurrentGuardianSet_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, "/publicrpc.v1.PublicRPCService/GetCurrentGuardianSet", runtime.WithHTTPPathPattern("/v1/guardianset/current"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_PublicRPCService_GetCurrentGuardianSet_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_PublicRPCService_GetCurrentGuardianSet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GovernorGetAvailableNotionalByChain_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, "/publicrpc.v1.PublicRPCService/GovernorGetAvailableNotionalByChain", runtime.WithHTTPPathPattern("/v1/governor/available_notional_by_chain"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_PublicRPCService_GovernorGetAvailableNotionalByChain_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_PublicRPCService_GovernorGetAvailableNotionalByChain_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GovernorGetEnqueuedVAAs_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, "/publicrpc.v1.PublicRPCService/GovernorGetEnqueuedVAAs", runtime.WithHTTPPathPattern("/v1/governor/enqueued_vaas"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_PublicRPCService_GovernorGetEnqueuedVAAs_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_PublicRPCService_GovernorGetEnqueuedVAAs_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GovernorIsVAAEnqueued_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, "/publicrpc.v1.PublicRPCService/GovernorIsVAAEnqueued", runtime.WithHTTPPathPattern("/v1/governor/is_vaa_enqueued/{message_id.emitter_chain}/{message_id.emitter_address}/{message_id.sequence}"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_PublicRPCService_GovernorIsVAAEnqueued_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_PublicRPCService_GovernorIsVAAEnqueued_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("GET", pattern_PublicRPCService_GovernorGetTokenList_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, "/publicrpc.v1.PublicRPCService/GovernorGetTokenList", runtime.WithHTTPPathPattern("/v1/governor/token_list"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_PublicRPCService_GovernorGetTokenList_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_PublicRPCService_GovernorGetTokenList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
var (
|
||||
pattern_PublicRPCService_GetLastHeartbeats_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "heartbeats"}, ""))
|
||||
|
||||
pattern_PublicRPCService_GetSignedVAA_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "signed_vaa", "message_id.emitter_chain", "message_id.emitter_address", "message_id.sequence"}, ""))
|
||||
|
||||
pattern_PublicRPCService_GetSignedBatchVAA_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "signed_batch_vaa", "batch_id.emitter_chain", "batch_id.tx_id", "batch_id.nonce"}, ""))
|
||||
|
||||
pattern_PublicRPCService_GetCurrentGuardianSet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "guardianset", "current"}, ""))
|
||||
|
||||
pattern_PublicRPCService_GovernorGetAvailableNotionalByChain_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "governor", "available_notional_by_chain"}, ""))
|
||||
|
||||
pattern_PublicRPCService_GovernorGetEnqueuedVAAs_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "governor", "enqueued_vaas"}, ""))
|
||||
|
||||
pattern_PublicRPCService_GovernorIsVAAEnqueued_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, 1, 0, 4, 1, 5, 5}, []string{"v1", "governor", "is_vaa_enqueued", "message_id.emitter_chain", "message_id.emitter_address", "message_id.sequence"}, ""))
|
||||
|
||||
pattern_PublicRPCService_GovernorGetTokenList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "governor", "token_list"}, ""))
|
||||
)
|
||||
|
||||
var (
|
||||
forward_PublicRPCService_GetLastHeartbeats_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_PublicRPCService_GetSignedVAA_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_PublicRPCService_GetSignedBatchVAA_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_PublicRPCService_GetCurrentGuardianSet_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_PublicRPCService_GovernorGetAvailableNotionalByChain_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_PublicRPCService_GovernorGetEnqueuedVAAs_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_PublicRPCService_GovernorIsVAAEnqueued_0 = runtime.ForwardResponseMessage
|
||||
|
||||
forward_PublicRPCService_GovernorGetTokenList_0 = runtime.ForwardResponseMessage
|
||||
)
|
|
@ -0,0 +1,359 @@
|
|||
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
||||
|
||||
package publicrpcv1
|
||||
|
||||
import (
|
||||
context "context"
|
||||
grpc "google.golang.org/grpc"
|
||||
codes "google.golang.org/grpc/codes"
|
||||
status "google.golang.org/grpc/status"
|
||||
)
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file
|
||||
// is compatible with the grpc package it is being compiled against.
|
||||
// Requires gRPC-Go v1.32.0 or later.
|
||||
const _ = grpc.SupportPackageIsVersion7
|
||||
|
||||
// PublicRPCServiceClient is the client API for PublicRPCService service.
|
||||
//
|
||||
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
||||
type PublicRPCServiceClient interface {
|
||||
// GetLastHeartbeats returns the last heartbeat received for each guardian node in the
|
||||
// node's active guardian set. Heartbeats received by nodes not in the guardian set are ignored.
|
||||
// The heartbeat value is null if no heartbeat has yet been received.
|
||||
GetLastHeartbeats(ctx context.Context, in *GetLastHeartbeatsRequest, opts ...grpc.CallOption) (*GetLastHeartbeatsResponse, error)
|
||||
GetSignedVAA(ctx context.Context, in *GetSignedVAARequest, opts ...grpc.CallOption) (*GetSignedVAAResponse, error)
|
||||
GetSignedBatchVAA(ctx context.Context, in *GetSignedBatchVAARequest, opts ...grpc.CallOption) (*GetSignedBatchVAAResponse, error)
|
||||
GetCurrentGuardianSet(ctx context.Context, in *GetCurrentGuardianSetRequest, opts ...grpc.CallOption) (*GetCurrentGuardianSetResponse, error)
|
||||
GovernorGetAvailableNotionalByChain(ctx context.Context, in *GovernorGetAvailableNotionalByChainRequest, opts ...grpc.CallOption) (*GovernorGetAvailableNotionalByChainResponse, error)
|
||||
GovernorGetEnqueuedVAAs(ctx context.Context, in *GovernorGetEnqueuedVAAsRequest, opts ...grpc.CallOption) (*GovernorGetEnqueuedVAAsResponse, error)
|
||||
GovernorIsVAAEnqueued(ctx context.Context, in *GovernorIsVAAEnqueuedRequest, opts ...grpc.CallOption) (*GovernorIsVAAEnqueuedResponse, error)
|
||||
GovernorGetTokenList(ctx context.Context, in *GovernorGetTokenListRequest, opts ...grpc.CallOption) (*GovernorGetTokenListResponse, error)
|
||||
}
|
||||
|
||||
type publicRPCServiceClient struct {
|
||||
cc grpc.ClientConnInterface
|
||||
}
|
||||
|
||||
func NewPublicRPCServiceClient(cc grpc.ClientConnInterface) PublicRPCServiceClient {
|
||||
return &publicRPCServiceClient{cc}
|
||||
}
|
||||
|
||||
func (c *publicRPCServiceClient) GetLastHeartbeats(ctx context.Context, in *GetLastHeartbeatsRequest, opts ...grpc.CallOption) (*GetLastHeartbeatsResponse, error) {
|
||||
out := new(GetLastHeartbeatsResponse)
|
||||
err := c.cc.Invoke(ctx, "/publicrpc.v1.PublicRPCService/GetLastHeartbeats", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *publicRPCServiceClient) GetSignedVAA(ctx context.Context, in *GetSignedVAARequest, opts ...grpc.CallOption) (*GetSignedVAAResponse, error) {
|
||||
out := new(GetSignedVAAResponse)
|
||||
err := c.cc.Invoke(ctx, "/publicrpc.v1.PublicRPCService/GetSignedVAA", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *publicRPCServiceClient) GetSignedBatchVAA(ctx context.Context, in *GetSignedBatchVAARequest, opts ...grpc.CallOption) (*GetSignedBatchVAAResponse, error) {
|
||||
out := new(GetSignedBatchVAAResponse)
|
||||
err := c.cc.Invoke(ctx, "/publicrpc.v1.PublicRPCService/GetSignedBatchVAA", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *publicRPCServiceClient) GetCurrentGuardianSet(ctx context.Context, in *GetCurrentGuardianSetRequest, opts ...grpc.CallOption) (*GetCurrentGuardianSetResponse, error) {
|
||||
out := new(GetCurrentGuardianSetResponse)
|
||||
err := c.cc.Invoke(ctx, "/publicrpc.v1.PublicRPCService/GetCurrentGuardianSet", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *publicRPCServiceClient) GovernorGetAvailableNotionalByChain(ctx context.Context, in *GovernorGetAvailableNotionalByChainRequest, opts ...grpc.CallOption) (*GovernorGetAvailableNotionalByChainResponse, error) {
|
||||
out := new(GovernorGetAvailableNotionalByChainResponse)
|
||||
err := c.cc.Invoke(ctx, "/publicrpc.v1.PublicRPCService/GovernorGetAvailableNotionalByChain", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *publicRPCServiceClient) GovernorGetEnqueuedVAAs(ctx context.Context, in *GovernorGetEnqueuedVAAsRequest, opts ...grpc.CallOption) (*GovernorGetEnqueuedVAAsResponse, error) {
|
||||
out := new(GovernorGetEnqueuedVAAsResponse)
|
||||
err := c.cc.Invoke(ctx, "/publicrpc.v1.PublicRPCService/GovernorGetEnqueuedVAAs", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *publicRPCServiceClient) GovernorIsVAAEnqueued(ctx context.Context, in *GovernorIsVAAEnqueuedRequest, opts ...grpc.CallOption) (*GovernorIsVAAEnqueuedResponse, error) {
|
||||
out := new(GovernorIsVAAEnqueuedResponse)
|
||||
err := c.cc.Invoke(ctx, "/publicrpc.v1.PublicRPCService/GovernorIsVAAEnqueued", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *publicRPCServiceClient) GovernorGetTokenList(ctx context.Context, in *GovernorGetTokenListRequest, opts ...grpc.CallOption) (*GovernorGetTokenListResponse, error) {
|
||||
out := new(GovernorGetTokenListResponse)
|
||||
err := c.cc.Invoke(ctx, "/publicrpc.v1.PublicRPCService/GovernorGetTokenList", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// PublicRPCServiceServer is the server API for PublicRPCService service.
|
||||
// All implementations must embed UnimplementedPublicRPCServiceServer
|
||||
// for forward compatibility
|
||||
type PublicRPCServiceServer interface {
|
||||
// GetLastHeartbeats returns the last heartbeat received for each guardian node in the
|
||||
// node's active guardian set. Heartbeats received by nodes not in the guardian set are ignored.
|
||||
// The heartbeat value is null if no heartbeat has yet been received.
|
||||
GetLastHeartbeats(context.Context, *GetLastHeartbeatsRequest) (*GetLastHeartbeatsResponse, error)
|
||||
GetSignedVAA(context.Context, *GetSignedVAARequest) (*GetSignedVAAResponse, error)
|
||||
GetSignedBatchVAA(context.Context, *GetSignedBatchVAARequest) (*GetSignedBatchVAAResponse, error)
|
||||
GetCurrentGuardianSet(context.Context, *GetCurrentGuardianSetRequest) (*GetCurrentGuardianSetResponse, error)
|
||||
GovernorGetAvailableNotionalByChain(context.Context, *GovernorGetAvailableNotionalByChainRequest) (*GovernorGetAvailableNotionalByChainResponse, error)
|
||||
GovernorGetEnqueuedVAAs(context.Context, *GovernorGetEnqueuedVAAsRequest) (*GovernorGetEnqueuedVAAsResponse, error)
|
||||
GovernorIsVAAEnqueued(context.Context, *GovernorIsVAAEnqueuedRequest) (*GovernorIsVAAEnqueuedResponse, error)
|
||||
GovernorGetTokenList(context.Context, *GovernorGetTokenListRequest) (*GovernorGetTokenListResponse, error)
|
||||
mustEmbedUnimplementedPublicRPCServiceServer()
|
||||
}
|
||||
|
||||
// UnimplementedPublicRPCServiceServer must be embedded to have forward compatible implementations.
|
||||
type UnimplementedPublicRPCServiceServer struct {
|
||||
}
|
||||
|
||||
func (UnimplementedPublicRPCServiceServer) GetLastHeartbeats(context.Context, *GetLastHeartbeatsRequest) (*GetLastHeartbeatsResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method GetLastHeartbeats not implemented")
|
||||
}
|
||||
func (UnimplementedPublicRPCServiceServer) GetSignedVAA(context.Context, *GetSignedVAARequest) (*GetSignedVAAResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method GetSignedVAA not implemented")
|
||||
}
|
||||
func (UnimplementedPublicRPCServiceServer) GetSignedBatchVAA(context.Context, *GetSignedBatchVAARequest) (*GetSignedBatchVAAResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method GetSignedBatchVAA not implemented")
|
||||
}
|
||||
func (UnimplementedPublicRPCServiceServer) GetCurrentGuardianSet(context.Context, *GetCurrentGuardianSetRequest) (*GetCurrentGuardianSetResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method GetCurrentGuardianSet not implemented")
|
||||
}
|
||||
func (UnimplementedPublicRPCServiceServer) GovernorGetAvailableNotionalByChain(context.Context, *GovernorGetAvailableNotionalByChainRequest) (*GovernorGetAvailableNotionalByChainResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method GovernorGetAvailableNotionalByChain not implemented")
|
||||
}
|
||||
func (UnimplementedPublicRPCServiceServer) GovernorGetEnqueuedVAAs(context.Context, *GovernorGetEnqueuedVAAsRequest) (*GovernorGetEnqueuedVAAsResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method GovernorGetEnqueuedVAAs not implemented")
|
||||
}
|
||||
func (UnimplementedPublicRPCServiceServer) GovernorIsVAAEnqueued(context.Context, *GovernorIsVAAEnqueuedRequest) (*GovernorIsVAAEnqueuedResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method GovernorIsVAAEnqueued not implemented")
|
||||
}
|
||||
func (UnimplementedPublicRPCServiceServer) GovernorGetTokenList(context.Context, *GovernorGetTokenListRequest) (*GovernorGetTokenListResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method GovernorGetTokenList not implemented")
|
||||
}
|
||||
func (UnimplementedPublicRPCServiceServer) mustEmbedUnimplementedPublicRPCServiceServer() {}
|
||||
|
||||
// UnsafePublicRPCServiceServer may be embedded to opt out of forward compatibility for this service.
|
||||
// Use of this interface is not recommended, as added methods to PublicRPCServiceServer will
|
||||
// result in compilation errors.
|
||||
type UnsafePublicRPCServiceServer interface {
|
||||
mustEmbedUnimplementedPublicRPCServiceServer()
|
||||
}
|
||||
|
||||
func RegisterPublicRPCServiceServer(s grpc.ServiceRegistrar, srv PublicRPCServiceServer) {
|
||||
s.RegisterService(&PublicRPCService_ServiceDesc, srv)
|
||||
}
|
||||
|
||||
func _PublicRPCService_GetLastHeartbeats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GetLastHeartbeatsRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(PublicRPCServiceServer).GetLastHeartbeats(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/publicrpc.v1.PublicRPCService/GetLastHeartbeats",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(PublicRPCServiceServer).GetLastHeartbeats(ctx, req.(*GetLastHeartbeatsRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _PublicRPCService_GetSignedVAA_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GetSignedVAARequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(PublicRPCServiceServer).GetSignedVAA(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/publicrpc.v1.PublicRPCService/GetSignedVAA",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(PublicRPCServiceServer).GetSignedVAA(ctx, req.(*GetSignedVAARequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _PublicRPCService_GetSignedBatchVAA_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GetSignedBatchVAARequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(PublicRPCServiceServer).GetSignedBatchVAA(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/publicrpc.v1.PublicRPCService/GetSignedBatchVAA",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(PublicRPCServiceServer).GetSignedBatchVAA(ctx, req.(*GetSignedBatchVAARequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _PublicRPCService_GetCurrentGuardianSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GetCurrentGuardianSetRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(PublicRPCServiceServer).GetCurrentGuardianSet(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/publicrpc.v1.PublicRPCService/GetCurrentGuardianSet",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(PublicRPCServiceServer).GetCurrentGuardianSet(ctx, req.(*GetCurrentGuardianSetRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _PublicRPCService_GovernorGetAvailableNotionalByChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GovernorGetAvailableNotionalByChainRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(PublicRPCServiceServer).GovernorGetAvailableNotionalByChain(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/publicrpc.v1.PublicRPCService/GovernorGetAvailableNotionalByChain",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(PublicRPCServiceServer).GovernorGetAvailableNotionalByChain(ctx, req.(*GovernorGetAvailableNotionalByChainRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _PublicRPCService_GovernorGetEnqueuedVAAs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GovernorGetEnqueuedVAAsRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(PublicRPCServiceServer).GovernorGetEnqueuedVAAs(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/publicrpc.v1.PublicRPCService/GovernorGetEnqueuedVAAs",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(PublicRPCServiceServer).GovernorGetEnqueuedVAAs(ctx, req.(*GovernorGetEnqueuedVAAsRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _PublicRPCService_GovernorIsVAAEnqueued_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GovernorIsVAAEnqueuedRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(PublicRPCServiceServer).GovernorIsVAAEnqueued(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/publicrpc.v1.PublicRPCService/GovernorIsVAAEnqueued",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(PublicRPCServiceServer).GovernorIsVAAEnqueued(ctx, req.(*GovernorIsVAAEnqueuedRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _PublicRPCService_GovernorGetTokenList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GovernorGetTokenListRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(PublicRPCServiceServer).GovernorGetTokenList(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/publicrpc.v1.PublicRPCService/GovernorGetTokenList",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(PublicRPCServiceServer).GovernorGetTokenList(ctx, req.(*GovernorGetTokenListRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
// PublicRPCService_ServiceDesc is the grpc.ServiceDesc for PublicRPCService service.
|
||||
// It's only intended for direct use with grpc.RegisterService,
|
||||
// and not to be introspected or modified (even as a copy)
|
||||
var PublicRPCService_ServiceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "publicrpc.v1.PublicRPCService",
|
||||
HandlerType: (*PublicRPCServiceServer)(nil),
|
||||
Methods: []grpc.MethodDesc{
|
||||
{
|
||||
MethodName: "GetLastHeartbeats",
|
||||
Handler: _PublicRPCService_GetLastHeartbeats_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GetSignedVAA",
|
||||
Handler: _PublicRPCService_GetSignedVAA_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GetSignedBatchVAA",
|
||||
Handler: _PublicRPCService_GetSignedBatchVAA_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GetCurrentGuardianSet",
|
||||
Handler: _PublicRPCService_GetCurrentGuardianSet_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GovernorGetAvailableNotionalByChain",
|
||||
Handler: _PublicRPCService_GovernorGetAvailableNotionalByChain_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GovernorGetEnqueuedVAAs",
|
||||
Handler: _PublicRPCService_GovernorGetEnqueuedVAAs_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GovernorIsVAAEnqueued",
|
||||
Handler: _PublicRPCService_GovernorIsVAAEnqueued_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GovernorGetTokenList",
|
||||
Handler: _PublicRPCService_GovernorGetTokenList_Handler,
|
||||
},
|
||||
},
|
||||
Streams: []grpc.StreamDesc{},
|
||||
Metadata: "publicrpc/v1/publicrpc.proto",
|
||||
}
|
|
@ -0,0 +1,804 @@
|
|||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// versions:
|
||||
// protoc-gen-go v1.27.1
|
||||
// protoc (unknown)
|
||||
// source: spy/v1/spy.proto
|
||||
|
||||
package spyv1
|
||||
|
||||
import (
|
||||
v11 "github.com/certusone/wormhole/node/pkg/proto/gossip/v1"
|
||||
v1 "github.com/certusone/wormhole/node/pkg/proto/publicrpc/v1"
|
||||
_ "google.golang.org/genproto/googleapis/api/annotations"
|
||||
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
||||
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
||||
reflect "reflect"
|
||||
sync "sync"
|
||||
)
|
||||
|
||||
const (
|
||||
// Verify that this generated code is sufficiently up-to-date.
|
||||
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
|
||||
// Verify that runtime/protoimpl is sufficiently up-to-date.
|
||||
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
|
||||
)
|
||||
|
||||
// A MessageFilter represents an exact match for an emitter.
|
||||
type EmitterFilter struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
// Source chain
|
||||
ChainId v1.ChainID `protobuf:"varint,1,opt,name=chain_id,json=chainId,proto3,enum=publicrpc.v1.ChainID" json:"chain_id,omitempty"`
|
||||
// Hex-encoded (without leading 0x) emitter address.
|
||||
EmitterAddress string `protobuf:"bytes,2,opt,name=emitter_address,json=emitterAddress,proto3" json:"emitter_address,omitempty"`
|
||||
}
|
||||
|
||||
func (x *EmitterFilter) Reset() {
|
||||
*x = EmitterFilter{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[0]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *EmitterFilter) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*EmitterFilter) ProtoMessage() {}
|
||||
|
||||
func (x *EmitterFilter) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[0]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use EmitterFilter.ProtoReflect.Descriptor instead.
|
||||
func (*EmitterFilter) Descriptor() ([]byte, []int) {
|
||||
return file_spy_v1_spy_proto_rawDescGZIP(), []int{0}
|
||||
}
|
||||
|
||||
func (x *EmitterFilter) GetChainId() v1.ChainID {
|
||||
if x != nil {
|
||||
return x.ChainId
|
||||
}
|
||||
return v1.ChainID(0)
|
||||
}
|
||||
|
||||
func (x *EmitterFilter) GetEmitterAddress() string {
|
||||
if x != nil {
|
||||
return x.EmitterAddress
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
type BatchFilter struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
// Source chain
|
||||
ChainId v1.ChainID `protobuf:"varint,1,opt,name=chain_id,json=chainId,proto3,enum=publicrpc.v1.ChainID" json:"chain_id,omitempty"`
|
||||
// Native transaction identifier bytes.
|
||||
TxId []byte `protobuf:"bytes,2,opt,name=tx_id,json=txId,proto3" json:"tx_id,omitempty"`
|
||||
// Nonce of the messages in the batch.
|
||||
Nonce uint32 `protobuf:"varint,3,opt,name=nonce,proto3" json:"nonce,omitempty"`
|
||||
}
|
||||
|
||||
func (x *BatchFilter) Reset() {
|
||||
*x = BatchFilter{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[1]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *BatchFilter) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*BatchFilter) ProtoMessage() {}
|
||||
|
||||
func (x *BatchFilter) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[1]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use BatchFilter.ProtoReflect.Descriptor instead.
|
||||
func (*BatchFilter) Descriptor() ([]byte, []int) {
|
||||
return file_spy_v1_spy_proto_rawDescGZIP(), []int{1}
|
||||
}
|
||||
|
||||
func (x *BatchFilter) GetChainId() v1.ChainID {
|
||||
if x != nil {
|
||||
return x.ChainId
|
||||
}
|
||||
return v1.ChainID(0)
|
||||
}
|
||||
|
||||
func (x *BatchFilter) GetTxId() []byte {
|
||||
if x != nil {
|
||||
return x.TxId
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *BatchFilter) GetNonce() uint32 {
|
||||
if x != nil {
|
||||
return x.Nonce
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
type BatchTransactionFilter struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
// Source chain
|
||||
ChainId v1.ChainID `protobuf:"varint,1,opt,name=chain_id,json=chainId,proto3,enum=publicrpc.v1.ChainID" json:"chain_id,omitempty"`
|
||||
// Native transaction identifier bytes.
|
||||
TxId []byte `protobuf:"bytes,2,opt,name=tx_id,json=txId,proto3" json:"tx_id,omitempty"`
|
||||
}
|
||||
|
||||
func (x *BatchTransactionFilter) Reset() {
|
||||
*x = BatchTransactionFilter{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[2]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *BatchTransactionFilter) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*BatchTransactionFilter) ProtoMessage() {}
|
||||
|
||||
func (x *BatchTransactionFilter) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[2]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use BatchTransactionFilter.ProtoReflect.Descriptor instead.
|
||||
func (*BatchTransactionFilter) Descriptor() ([]byte, []int) {
|
||||
return file_spy_v1_spy_proto_rawDescGZIP(), []int{2}
|
||||
}
|
||||
|
||||
func (x *BatchTransactionFilter) GetChainId() v1.ChainID {
|
||||
if x != nil {
|
||||
return x.ChainId
|
||||
}
|
||||
return v1.ChainID(0)
|
||||
}
|
||||
|
||||
func (x *BatchTransactionFilter) GetTxId() []byte {
|
||||
if x != nil {
|
||||
return x.TxId
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type FilterEntry struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
// Types that are assignable to Filter:
|
||||
//
|
||||
// *FilterEntry_EmitterFilter
|
||||
// *FilterEntry_BatchFilter
|
||||
// *FilterEntry_BatchTransactionFilter
|
||||
Filter isFilterEntry_Filter `protobuf_oneof:"filter"`
|
||||
}
|
||||
|
||||
func (x *FilterEntry) Reset() {
|
||||
*x = FilterEntry{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[3]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *FilterEntry) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*FilterEntry) ProtoMessage() {}
|
||||
|
||||
func (x *FilterEntry) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[3]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use FilterEntry.ProtoReflect.Descriptor instead.
|
||||
func (*FilterEntry) Descriptor() ([]byte, []int) {
|
||||
return file_spy_v1_spy_proto_rawDescGZIP(), []int{3}
|
||||
}
|
||||
|
||||
func (m *FilterEntry) GetFilter() isFilterEntry_Filter {
|
||||
if m != nil {
|
||||
return m.Filter
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *FilterEntry) GetEmitterFilter() *EmitterFilter {
|
||||
if x, ok := x.GetFilter().(*FilterEntry_EmitterFilter); ok {
|
||||
return x.EmitterFilter
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *FilterEntry) GetBatchFilter() *BatchFilter {
|
||||
if x, ok := x.GetFilter().(*FilterEntry_BatchFilter); ok {
|
||||
return x.BatchFilter
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *FilterEntry) GetBatchTransactionFilter() *BatchTransactionFilter {
|
||||
if x, ok := x.GetFilter().(*FilterEntry_BatchTransactionFilter); ok {
|
||||
return x.BatchTransactionFilter
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type isFilterEntry_Filter interface {
|
||||
isFilterEntry_Filter()
|
||||
}
|
||||
|
||||
type FilterEntry_EmitterFilter struct {
|
||||
EmitterFilter *EmitterFilter `protobuf:"bytes,1,opt,name=emitter_filter,json=emitterFilter,proto3,oneof"`
|
||||
}
|
||||
|
||||
type FilterEntry_BatchFilter struct {
|
||||
BatchFilter *BatchFilter `protobuf:"bytes,2,opt,name=batch_filter,json=batchFilter,proto3,oneof"`
|
||||
}
|
||||
|
||||
type FilterEntry_BatchTransactionFilter struct {
|
||||
BatchTransactionFilter *BatchTransactionFilter `protobuf:"bytes,3,opt,name=batch_transaction_filter,json=batchTransactionFilter,proto3,oneof"`
|
||||
}
|
||||
|
||||
func (*FilterEntry_EmitterFilter) isFilterEntry_Filter() {}
|
||||
|
||||
func (*FilterEntry_BatchFilter) isFilterEntry_Filter() {}
|
||||
|
||||
func (*FilterEntry_BatchTransactionFilter) isFilterEntry_Filter() {}
|
||||
|
||||
type SubscribeSignedVAARequest struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
// List of filters to apply to the stream (OR).
|
||||
// If empty, all messages are streamed.
|
||||
Filters []*FilterEntry `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAARequest) Reset() {
|
||||
*x = SubscribeSignedVAARequest{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[4]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAARequest) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*SubscribeSignedVAARequest) ProtoMessage() {}
|
||||
|
||||
func (x *SubscribeSignedVAARequest) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[4]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use SubscribeSignedVAARequest.ProtoReflect.Descriptor instead.
|
||||
func (*SubscribeSignedVAARequest) Descriptor() ([]byte, []int) {
|
||||
return file_spy_v1_spy_proto_rawDescGZIP(), []int{4}
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAARequest) GetFilters() []*FilterEntry {
|
||||
if x != nil {
|
||||
return x.Filters
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type SubscribeSignedVAAByTypeRequest struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
// List of filters to apply to the stream (OR).
|
||||
// If empty, all messages are streamed.
|
||||
Filters []*FilterEntry `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAAByTypeRequest) Reset() {
|
||||
*x = SubscribeSignedVAAByTypeRequest{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[5]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAAByTypeRequest) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*SubscribeSignedVAAByTypeRequest) ProtoMessage() {}
|
||||
|
||||
func (x *SubscribeSignedVAAByTypeRequest) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[5]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use SubscribeSignedVAAByTypeRequest.ProtoReflect.Descriptor instead.
|
||||
func (*SubscribeSignedVAAByTypeRequest) Descriptor() ([]byte, []int) {
|
||||
return file_spy_v1_spy_proto_rawDescGZIP(), []int{5}
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAAByTypeRequest) GetFilters() []*FilterEntry {
|
||||
if x != nil {
|
||||
return x.Filters
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type SubscribeSignedVAAResponse struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
// Raw VAA bytes
|
||||
VaaBytes []byte `protobuf:"bytes,1,opt,name=vaa_bytes,json=vaaBytes,proto3" json:"vaa_bytes,omitempty"`
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAAResponse) Reset() {
|
||||
*x = SubscribeSignedVAAResponse{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[6]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAAResponse) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*SubscribeSignedVAAResponse) ProtoMessage() {}
|
||||
|
||||
func (x *SubscribeSignedVAAResponse) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[6]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use SubscribeSignedVAAResponse.ProtoReflect.Descriptor instead.
|
||||
func (*SubscribeSignedVAAResponse) Descriptor() ([]byte, []int) {
|
||||
return file_spy_v1_spy_proto_rawDescGZIP(), []int{6}
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAAResponse) GetVaaBytes() []byte {
|
||||
if x != nil {
|
||||
return x.VaaBytes
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type SubscribeSignedVAAByTypeResponse struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
// Types that are assignable to VaaType:
|
||||
//
|
||||
// *SubscribeSignedVAAByTypeResponse_SignedVaa
|
||||
// *SubscribeSignedVAAByTypeResponse_SignedBatchVaa
|
||||
VaaType isSubscribeSignedVAAByTypeResponse_VaaType `protobuf_oneof:"vaa_type"`
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAAByTypeResponse) Reset() {
|
||||
*x = SubscribeSignedVAAByTypeResponse{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[7]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAAByTypeResponse) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*SubscribeSignedVAAByTypeResponse) ProtoMessage() {}
|
||||
|
||||
func (x *SubscribeSignedVAAByTypeResponse) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_spy_v1_spy_proto_msgTypes[7]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use SubscribeSignedVAAByTypeResponse.ProtoReflect.Descriptor instead.
|
||||
func (*SubscribeSignedVAAByTypeResponse) Descriptor() ([]byte, []int) {
|
||||
return file_spy_v1_spy_proto_rawDescGZIP(), []int{7}
|
||||
}
|
||||
|
||||
func (m *SubscribeSignedVAAByTypeResponse) GetVaaType() isSubscribeSignedVAAByTypeResponse_VaaType {
|
||||
if m != nil {
|
||||
return m.VaaType
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAAByTypeResponse) GetSignedVaa() *v11.SignedVAAWithQuorum {
|
||||
if x, ok := x.GetVaaType().(*SubscribeSignedVAAByTypeResponse_SignedVaa); ok {
|
||||
return x.SignedVaa
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *SubscribeSignedVAAByTypeResponse) GetSignedBatchVaa() *v11.SignedBatchVAAWithQuorum {
|
||||
if x, ok := x.GetVaaType().(*SubscribeSignedVAAByTypeResponse_SignedBatchVaa); ok {
|
||||
return x.SignedBatchVaa
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type isSubscribeSignedVAAByTypeResponse_VaaType interface {
|
||||
isSubscribeSignedVAAByTypeResponse_VaaType()
|
||||
}
|
||||
|
||||
type SubscribeSignedVAAByTypeResponse_SignedVaa struct {
|
||||
SignedVaa *v11.SignedVAAWithQuorum `protobuf:"bytes,1,opt,name=signed_vaa,json=signedVaa,proto3,oneof"`
|
||||
}
|
||||
|
||||
type SubscribeSignedVAAByTypeResponse_SignedBatchVaa struct {
|
||||
SignedBatchVaa *v11.SignedBatchVAAWithQuorum `protobuf:"bytes,2,opt,name=signed_batch_vaa,json=signedBatchVaa,proto3,oneof"`
|
||||
}
|
||||
|
||||
func (*SubscribeSignedVAAByTypeResponse_SignedVaa) isSubscribeSignedVAAByTypeResponse_VaaType() {}
|
||||
|
||||
func (*SubscribeSignedVAAByTypeResponse_SignedBatchVaa) isSubscribeSignedVAAByTypeResponse_VaaType() {
|
||||
}
|
||||
|
||||
var File_spy_v1_spy_proto protoreflect.FileDescriptor
|
||||
|
||||
var file_spy_v1_spy_proto_rawDesc = []byte{
|
||||
0x0a, 0x10, 0x73, 0x70, 0x79, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x70, 0x79, 0x2e, 0x70, 0x72, 0x6f,
|
||||
0x74, 0x6f, 0x12, 0x06, 0x73, 0x70, 0x79, 0x2e, 0x76, 0x31, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67,
|
||||
0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f,
|
||||
0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x16, 0x67, 0x6f, 0x73, 0x73, 0x69, 0x70,
|
||||
0x2f, 0x76, 0x31, 0x2f, 0x67, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
|
||||
0x1a, 0x1c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x72, 0x70, 0x63, 0x2f, 0x76, 0x31, 0x2f, 0x70,
|
||||
0x75, 0x62, 0x6c, 0x69, 0x63, 0x72, 0x70, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x6a,
|
||||
0x0a, 0x0d, 0x45, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12,
|
||||
0x30, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
|
||||
0x0e, 0x32, 0x15, 0x2e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x72, 0x70, 0x63, 0x2e, 0x76, 0x31,
|
||||
0x2e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x44, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49,
|
||||
0x64, 0x12, 0x27, 0x0a, 0x0f, 0x65, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64,
|
||||
0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x65, 0x6d, 0x69, 0x74,
|
||||
0x74, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x6a, 0x0a, 0x0b, 0x42, 0x61,
|
||||
0x74, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x08, 0x63, 0x68, 0x61,
|
||||
0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x70, 0x75,
|
||||
0x62, 0x6c, 0x69, 0x63, 0x72, 0x70, 0x63, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x61, 0x69, 0x6e,
|
||||
0x49, 0x44, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x13, 0x0a, 0x05, 0x74,
|
||||
0x78, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x74, 0x78, 0x49, 0x64,
|
||||
0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52,
|
||||
0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x5f, 0x0a, 0x16, 0x42, 0x61, 0x74, 0x63, 0x68, 0x54,
|
||||
0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72,
|
||||
0x12, 0x30, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
|
||||
0x28, 0x0e, 0x32, 0x15, 0x2e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x72, 0x70, 0x63, 0x2e, 0x76,
|
||||
0x31, 0x2e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x44, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e,
|
||||
0x49, 0x64, 0x12, 0x13, 0x0a, 0x05, 0x74, 0x78, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
|
||||
0x0c, 0x52, 0x04, 0x74, 0x78, 0x49, 0x64, 0x22, 0xed, 0x01, 0x0a, 0x0b, 0x46, 0x69, 0x6c, 0x74,
|
||||
0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x3e, 0x0a, 0x0e, 0x65, 0x6d, 0x69, 0x74, 0x74,
|
||||
0x65, 0x72, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
|
||||
0x15, 0x2e, 0x73, 0x70, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72,
|
||||
0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x48, 0x00, 0x52, 0x0d, 0x65, 0x6d, 0x69, 0x74, 0x74, 0x65,
|
||||
0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x38, 0x0a, 0x0c, 0x62, 0x61, 0x74, 0x63, 0x68,
|
||||
0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e,
|
||||
0x73, 0x70, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x74,
|
||||
0x65, 0x72, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x61, 0x74, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x74, 0x65,
|
||||
0x72, 0x12, 0x5a, 0x0a, 0x18, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73,
|
||||
0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20,
|
||||
0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x70, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x61, 0x74,
|
||||
0x63, 0x68, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6c,
|
||||
0x74, 0x65, 0x72, 0x48, 0x00, 0x52, 0x16, 0x62, 0x61, 0x74, 0x63, 0x68, 0x54, 0x72, 0x61, 0x6e,
|
||||
0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x42, 0x08, 0x0a,
|
||||
0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x4a, 0x0a, 0x19, 0x53, 0x75, 0x62, 0x73, 0x63,
|
||||
0x72, 0x69, 0x62, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x41, 0x41, 0x52, 0x65, 0x71,
|
||||
0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x18,
|
||||
0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x73, 0x70, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x46,
|
||||
0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74,
|
||||
0x65, 0x72, 0x73, 0x22, 0x50, 0x0a, 0x1f, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65,
|
||||
0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x41, 0x41, 0x42, 0x79, 0x54, 0x79, 0x70, 0x65, 0x52,
|
||||
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72,
|
||||
0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x73, 0x70, 0x79, 0x2e, 0x76, 0x31,
|
||||
0x2e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x66, 0x69,
|
||||
0x6c, 0x74, 0x65, 0x72, 0x73, 0x22, 0x39, 0x0a, 0x1a, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69,
|
||||
0x62, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x41, 0x41, 0x52, 0x65, 0x73, 0x70, 0x6f,
|
||||
0x6e, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x76, 0x61, 0x61, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73,
|
||||
0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x76, 0x61, 0x61, 0x42, 0x79, 0x74, 0x65, 0x73,
|
||||
0x22, 0xc0, 0x01, 0x0a, 0x20, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x53, 0x69,
|
||||
0x67, 0x6e, 0x65, 0x64, 0x56, 0x41, 0x41, 0x42, 0x79, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73,
|
||||
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f,
|
||||
0x76, 0x61, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x73, 0x73,
|
||||
0x69, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x41, 0x41, 0x57,
|
||||
0x69, 0x74, 0x68, 0x51, 0x75, 0x6f, 0x72, 0x75, 0x6d, 0x48, 0x00, 0x52, 0x09, 0x73, 0x69, 0x67,
|
||||
0x6e, 0x65, 0x64, 0x56, 0x61, 0x61, 0x12, 0x4f, 0x0a, 0x10, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64,
|
||||
0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x76, 0x61, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
|
||||
0x32, 0x23, 0x2e, 0x67, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x69, 0x67,
|
||||
0x6e, 0x65, 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x56, 0x41, 0x41, 0x57, 0x69, 0x74, 0x68, 0x51,
|
||||
0x75, 0x6f, 0x72, 0x75, 0x6d, 0x48, 0x00, 0x52, 0x0e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x42,
|
||||
0x61, 0x74, 0x63, 0x68, 0x56, 0x61, 0x61, 0x42, 0x0a, 0x0a, 0x08, 0x76, 0x61, 0x61, 0x5f, 0x74,
|
||||
0x79, 0x70, 0x65, 0x32, 0xb3, 0x02, 0x0a, 0x0d, 0x53, 0x70, 0x79, 0x52, 0x50, 0x43, 0x53, 0x65,
|
||||
0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x82, 0x01, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72,
|
||||
0x69, 0x62, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x41, 0x41, 0x12, 0x21, 0x2e, 0x73,
|
||||
0x70, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x53,
|
||||
0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x41, 0x41, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
|
||||
0x22, 0x2e, 0x73, 0x70, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69,
|
||||
0x62, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x41, 0x41, 0x52, 0x65, 0x73, 0x70, 0x6f,
|
||||
0x6e, 0x73, 0x65, 0x22, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x22, 0x18, 0x2f, 0x76, 0x31,
|
||||
0x3a, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x65,
|
||||
0x64, 0x5f, 0x76, 0x61, 0x61, 0x3a, 0x01, 0x2a, 0x30, 0x01, 0x12, 0x9c, 0x01, 0x0a, 0x18, 0x53,
|
||||
0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x41,
|
||||
0x41, 0x42, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x27, 0x2e, 0x73, 0x70, 0x79, 0x2e, 0x76, 0x31,
|
||||
0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64,
|
||||
0x56, 0x41, 0x41, 0x42, 0x79, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
|
||||
0x1a, 0x28, 0x2e, 0x73, 0x70, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72,
|
||||
0x69, 0x62, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x41, 0x41, 0x42, 0x79, 0x54, 0x79,
|
||||
0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0x82, 0xd3, 0xe4, 0x93,
|
||||
0x02, 0x25, 0x22, 0x20, 0x2f, 0x76, 0x31, 0x3a, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62,
|
||||
0x65, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x61, 0x5f, 0x62, 0x79, 0x5f,
|
||||
0x74, 0x79, 0x70, 0x65, 0x3a, 0x01, 0x2a, 0x30, 0x01, 0x42, 0x3b, 0x5a, 0x39, 0x67, 0x69, 0x74,
|
||||
0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x65, 0x72, 0x74, 0x75, 0x73, 0x6f, 0x6e,
|
||||
0x65, 0x2f, 0x77, 0x6f, 0x72, 0x6d, 0x68, 0x6f, 0x6c, 0x65, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f,
|
||||
0x70, 0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x73, 0x70, 0x79, 0x2f, 0x76, 0x31,
|
||||
0x3b, 0x73, 0x70, 0x79, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
|
||||
}
|
||||
|
||||
var (
|
||||
file_spy_v1_spy_proto_rawDescOnce sync.Once
|
||||
file_spy_v1_spy_proto_rawDescData = file_spy_v1_spy_proto_rawDesc
|
||||
)
|
||||
|
||||
func file_spy_v1_spy_proto_rawDescGZIP() []byte {
|
||||
file_spy_v1_spy_proto_rawDescOnce.Do(func() {
|
||||
file_spy_v1_spy_proto_rawDescData = protoimpl.X.CompressGZIP(file_spy_v1_spy_proto_rawDescData)
|
||||
})
|
||||
return file_spy_v1_spy_proto_rawDescData
|
||||
}
|
||||
|
||||
var file_spy_v1_spy_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
|
||||
var file_spy_v1_spy_proto_goTypes = []interface{}{
|
||||
(*EmitterFilter)(nil), // 0: spy.v1.EmitterFilter
|
||||
(*BatchFilter)(nil), // 1: spy.v1.BatchFilter
|
||||
(*BatchTransactionFilter)(nil), // 2: spy.v1.BatchTransactionFilter
|
||||
(*FilterEntry)(nil), // 3: spy.v1.FilterEntry
|
||||
(*SubscribeSignedVAARequest)(nil), // 4: spy.v1.SubscribeSignedVAARequest
|
||||
(*SubscribeSignedVAAByTypeRequest)(nil), // 5: spy.v1.SubscribeSignedVAAByTypeRequest
|
||||
(*SubscribeSignedVAAResponse)(nil), // 6: spy.v1.SubscribeSignedVAAResponse
|
||||
(*SubscribeSignedVAAByTypeResponse)(nil), // 7: spy.v1.SubscribeSignedVAAByTypeResponse
|
||||
(v1.ChainID)(0), // 8: publicrpc.v1.ChainID
|
||||
(*v11.SignedVAAWithQuorum)(nil), // 9: gossip.v1.SignedVAAWithQuorum
|
||||
(*v11.SignedBatchVAAWithQuorum)(nil), // 10: gossip.v1.SignedBatchVAAWithQuorum
|
||||
}
|
||||
var file_spy_v1_spy_proto_depIdxs = []int32{
|
||||
8, // 0: spy.v1.EmitterFilter.chain_id:type_name -> publicrpc.v1.ChainID
|
||||
8, // 1: spy.v1.BatchFilter.chain_id:type_name -> publicrpc.v1.ChainID
|
||||
8, // 2: spy.v1.BatchTransactionFilter.chain_id:type_name -> publicrpc.v1.ChainID
|
||||
0, // 3: spy.v1.FilterEntry.emitter_filter:type_name -> spy.v1.EmitterFilter
|
||||
1, // 4: spy.v1.FilterEntry.batch_filter:type_name -> spy.v1.BatchFilter
|
||||
2, // 5: spy.v1.FilterEntry.batch_transaction_filter:type_name -> spy.v1.BatchTransactionFilter
|
||||
3, // 6: spy.v1.SubscribeSignedVAARequest.filters:type_name -> spy.v1.FilterEntry
|
||||
3, // 7: spy.v1.SubscribeSignedVAAByTypeRequest.filters:type_name -> spy.v1.FilterEntry
|
||||
9, // 8: spy.v1.SubscribeSignedVAAByTypeResponse.signed_vaa:type_name -> gossip.v1.SignedVAAWithQuorum
|
||||
10, // 9: spy.v1.SubscribeSignedVAAByTypeResponse.signed_batch_vaa:type_name -> gossip.v1.SignedBatchVAAWithQuorum
|
||||
4, // 10: spy.v1.SpyRPCService.SubscribeSignedVAA:input_type -> spy.v1.SubscribeSignedVAARequest
|
||||
5, // 11: spy.v1.SpyRPCService.SubscribeSignedVAAByType:input_type -> spy.v1.SubscribeSignedVAAByTypeRequest
|
||||
6, // 12: spy.v1.SpyRPCService.SubscribeSignedVAA:output_type -> spy.v1.SubscribeSignedVAAResponse
|
||||
7, // 13: spy.v1.SpyRPCService.SubscribeSignedVAAByType:output_type -> spy.v1.SubscribeSignedVAAByTypeResponse
|
||||
12, // [12:14] is the sub-list for method output_type
|
||||
10, // [10:12] is the sub-list for method input_type
|
||||
10, // [10:10] is the sub-list for extension type_name
|
||||
10, // [10:10] is the sub-list for extension extendee
|
||||
0, // [0:10] is the sub-list for field type_name
|
||||
}
|
||||
|
||||
func init() { file_spy_v1_spy_proto_init() }
|
||||
func file_spy_v1_spy_proto_init() {
|
||||
if File_spy_v1_spy_proto != nil {
|
||||
return
|
||||
}
|
||||
if !protoimpl.UnsafeEnabled {
|
||||
file_spy_v1_spy_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*EmitterFilter); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_spy_v1_spy_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*BatchFilter); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_spy_v1_spy_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*BatchTransactionFilter); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_spy_v1_spy_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*FilterEntry); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_spy_v1_spy_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*SubscribeSignedVAARequest); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_spy_v1_spy_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*SubscribeSignedVAAByTypeRequest); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_spy_v1_spy_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*SubscribeSignedVAAResponse); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_spy_v1_spy_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*SubscribeSignedVAAByTypeResponse); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
file_spy_v1_spy_proto_msgTypes[3].OneofWrappers = []interface{}{
|
||||
(*FilterEntry_EmitterFilter)(nil),
|
||||
(*FilterEntry_BatchFilter)(nil),
|
||||
(*FilterEntry_BatchTransactionFilter)(nil),
|
||||
}
|
||||
file_spy_v1_spy_proto_msgTypes[7].OneofWrappers = []interface{}{
|
||||
(*SubscribeSignedVAAByTypeResponse_SignedVaa)(nil),
|
||||
(*SubscribeSignedVAAByTypeResponse_SignedBatchVaa)(nil),
|
||||
}
|
||||
type x struct{}
|
||||
out := protoimpl.TypeBuilder{
|
||||
File: protoimpl.DescBuilder{
|
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
||||
RawDescriptor: file_spy_v1_spy_proto_rawDesc,
|
||||
NumEnums: 0,
|
||||
NumMessages: 8,
|
||||
NumExtensions: 0,
|
||||
NumServices: 1,
|
||||
},
|
||||
GoTypes: file_spy_v1_spy_proto_goTypes,
|
||||
DependencyIndexes: file_spy_v1_spy_proto_depIdxs,
|
||||
MessageInfos: file_spy_v1_spy_proto_msgTypes,
|
||||
}.Build()
|
||||
File_spy_v1_spy_proto = out.File
|
||||
file_spy_v1_spy_proto_rawDesc = nil
|
||||
file_spy_v1_spy_proto_goTypes = nil
|
||||
file_spy_v1_spy_proto_depIdxs = nil
|
||||
}
|
|
@ -0,0 +1,198 @@
|
|||
// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
|
||||
// source: spy/v1/spy.proto
|
||||
|
||||
/*
|
||||
Package spyv1 is a reverse proxy.
|
||||
|
||||
It translates gRPC into RESTful JSON APIs.
|
||||
*/
|
||||
package spyv1
|
||||
|
||||
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_SpyRPCService_SubscribeSignedVAA_0(ctx context.Context, marshaler runtime.Marshaler, client SpyRPCServiceClient, req *http.Request, pathParams map[string]string) (SpyRPCService_SubscribeSignedVAAClient, runtime.ServerMetadata, error) {
|
||||
var protoReq SubscribeSignedVAARequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
newReader, berr := utilities.IOReaderFactory(req.Body)
|
||||
if berr != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
|
||||
}
|
||||
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
stream, err := client.SubscribeSignedVAA(ctx, &protoReq)
|
||||
if err != nil {
|
||||
return nil, metadata, err
|
||||
}
|
||||
header, err := stream.Header()
|
||||
if err != nil {
|
||||
return nil, metadata, err
|
||||
}
|
||||
metadata.HeaderMD = header
|
||||
return stream, metadata, nil
|
||||
|
||||
}
|
||||
|
||||
func request_SpyRPCService_SubscribeSignedVAAByType_0(ctx context.Context, marshaler runtime.Marshaler, client SpyRPCServiceClient, req *http.Request, pathParams map[string]string) (SpyRPCService_SubscribeSignedVAAByTypeClient, runtime.ServerMetadata, error) {
|
||||
var protoReq SubscribeSignedVAAByTypeRequest
|
||||
var metadata runtime.ServerMetadata
|
||||
|
||||
newReader, berr := utilities.IOReaderFactory(req.Body)
|
||||
if berr != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
|
||||
}
|
||||
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
|
||||
stream, err := client.SubscribeSignedVAAByType(ctx, &protoReq)
|
||||
if err != nil {
|
||||
return nil, metadata, err
|
||||
}
|
||||
header, err := stream.Header()
|
||||
if err != nil {
|
||||
return nil, metadata, err
|
||||
}
|
||||
metadata.HeaderMD = header
|
||||
return stream, metadata, nil
|
||||
|
||||
}
|
||||
|
||||
// RegisterSpyRPCServiceHandlerServer registers the http handlers for service SpyRPCService to "mux".
|
||||
// UnaryRPC :call SpyRPCServiceServer 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 RegisterSpyRPCServiceHandlerFromEndpoint instead.
|
||||
func RegisterSpyRPCServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SpyRPCServiceServer) error {
|
||||
|
||||
mux.Handle("POST", pattern_SpyRPCService_SubscribeSignedVAA_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
|
||||
_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_SpyRPCService_SubscribeSignedVAAByType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
|
||||
_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// RegisterSpyRPCServiceHandlerFromEndpoint is same as RegisterSpyRPCServiceHandler but
|
||||
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
|
||||
func RegisterSpyRPCServiceHandlerFromEndpoint(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 RegisterSpyRPCServiceHandler(ctx, mux, conn)
|
||||
}
|
||||
|
||||
// RegisterSpyRPCServiceHandler registers the http handlers for service SpyRPCService to "mux".
|
||||
// The handlers forward requests to the grpc endpoint over "conn".
|
||||
func RegisterSpyRPCServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
|
||||
return RegisterSpyRPCServiceHandlerClient(ctx, mux, NewSpyRPCServiceClient(conn))
|
||||
}
|
||||
|
||||
// RegisterSpyRPCServiceHandlerClient registers the http handlers for service SpyRPCService
|
||||
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "SpyRPCServiceClient".
|
||||
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SpyRPCServiceClient"
|
||||
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
|
||||
// "SpyRPCServiceClient" to call the correct interceptors.
|
||||
func RegisterSpyRPCServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SpyRPCServiceClient) error {
|
||||
|
||||
mux.Handle("POST", pattern_SpyRPCService_SubscribeSignedVAA_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, "/spy.v1.SpyRPCService/SubscribeSignedVAA", runtime.WithHTTPPathPattern("/v1:subscribe_signed_vaa"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_SpyRPCService_SubscribeSignedVAA_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_SpyRPCService_SubscribeSignedVAA_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
mux.Handle("POST", pattern_SpyRPCService_SubscribeSignedVAAByType_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, "/spy.v1.SpyRPCService/SubscribeSignedVAAByType", runtime.WithHTTPPathPattern("/v1:subscribe_signed_vaa_by_type"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_SpyRPCService_SubscribeSignedVAAByType_0(rctx, inboundMarshaler, client, req, pathParams)
|
||||
ctx = runtime.NewServerMetadataContext(ctx, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
|
||||
forward_SpyRPCService_SubscribeSignedVAAByType_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
|
||||
|
||||
})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
var (
|
||||
pattern_SpyRPCService_SubscribeSignedVAA_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"v1"}, "subscribe_signed_vaa"))
|
||||
|
||||
pattern_SpyRPCService_SubscribeSignedVAAByType_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"v1"}, "subscribe_signed_vaa_by_type"))
|
||||
)
|
||||
|
||||
var (
|
||||
forward_SpyRPCService_SubscribeSignedVAA_0 = runtime.ForwardResponseStream
|
||||
|
||||
forward_SpyRPCService_SubscribeSignedVAAByType_0 = runtime.ForwardResponseStream
|
||||
)
|
|
@ -0,0 +1,195 @@
|
|||
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
||||
|
||||
package spyv1
|
||||
|
||||
import (
|
||||
context "context"
|
||||
grpc "google.golang.org/grpc"
|
||||
codes "google.golang.org/grpc/codes"
|
||||
status "google.golang.org/grpc/status"
|
||||
)
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file
|
||||
// is compatible with the grpc package it is being compiled against.
|
||||
// Requires gRPC-Go v1.32.0 or later.
|
||||
const _ = grpc.SupportPackageIsVersion7
|
||||
|
||||
// SpyRPCServiceClient is the client API for SpyRPCService service.
|
||||
//
|
||||
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
||||
type SpyRPCServiceClient interface {
|
||||
// SubscribeSignedVAA returns a stream of signed VAA messages received on the network.
|
||||
SubscribeSignedVAA(ctx context.Context, in *SubscribeSignedVAARequest, opts ...grpc.CallOption) (SpyRPCService_SubscribeSignedVAAClient, error)
|
||||
// SubscribeSignedBatchVAA returns a stream of signed VAA messages, by type, received on the network.
|
||||
SubscribeSignedVAAByType(ctx context.Context, in *SubscribeSignedVAAByTypeRequest, opts ...grpc.CallOption) (SpyRPCService_SubscribeSignedVAAByTypeClient, error)
|
||||
}
|
||||
|
||||
type spyRPCServiceClient struct {
|
||||
cc grpc.ClientConnInterface
|
||||
}
|
||||
|
||||
func NewSpyRPCServiceClient(cc grpc.ClientConnInterface) SpyRPCServiceClient {
|
||||
return &spyRPCServiceClient{cc}
|
||||
}
|
||||
|
||||
func (c *spyRPCServiceClient) SubscribeSignedVAA(ctx context.Context, in *SubscribeSignedVAARequest, opts ...grpc.CallOption) (SpyRPCService_SubscribeSignedVAAClient, error) {
|
||||
stream, err := c.cc.NewStream(ctx, &SpyRPCService_ServiceDesc.Streams[0], "/spy.v1.SpyRPCService/SubscribeSignedVAA", opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
x := &spyRPCServiceSubscribeSignedVAAClient{stream}
|
||||
if err := x.ClientStream.SendMsg(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := x.ClientStream.CloseSend(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return x, nil
|
||||
}
|
||||
|
||||
type SpyRPCService_SubscribeSignedVAAClient interface {
|
||||
Recv() (*SubscribeSignedVAAResponse, error)
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
type spyRPCServiceSubscribeSignedVAAClient struct {
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
func (x *spyRPCServiceSubscribeSignedVAAClient) Recv() (*SubscribeSignedVAAResponse, error) {
|
||||
m := new(SubscribeSignedVAAResponse)
|
||||
if err := x.ClientStream.RecvMsg(m); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (c *spyRPCServiceClient) SubscribeSignedVAAByType(ctx context.Context, in *SubscribeSignedVAAByTypeRequest, opts ...grpc.CallOption) (SpyRPCService_SubscribeSignedVAAByTypeClient, error) {
|
||||
stream, err := c.cc.NewStream(ctx, &SpyRPCService_ServiceDesc.Streams[1], "/spy.v1.SpyRPCService/SubscribeSignedVAAByType", opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
x := &spyRPCServiceSubscribeSignedVAAByTypeClient{stream}
|
||||
if err := x.ClientStream.SendMsg(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := x.ClientStream.CloseSend(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return x, nil
|
||||
}
|
||||
|
||||
type SpyRPCService_SubscribeSignedVAAByTypeClient interface {
|
||||
Recv() (*SubscribeSignedVAAByTypeResponse, error)
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
type spyRPCServiceSubscribeSignedVAAByTypeClient struct {
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
func (x *spyRPCServiceSubscribeSignedVAAByTypeClient) Recv() (*SubscribeSignedVAAByTypeResponse, error) {
|
||||
m := new(SubscribeSignedVAAByTypeResponse)
|
||||
if err := x.ClientStream.RecvMsg(m); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// SpyRPCServiceServer is the server API for SpyRPCService service.
|
||||
// All implementations must embed UnimplementedSpyRPCServiceServer
|
||||
// for forward compatibility
|
||||
type SpyRPCServiceServer interface {
|
||||
// SubscribeSignedVAA returns a stream of signed VAA messages received on the network.
|
||||
SubscribeSignedVAA(*SubscribeSignedVAARequest, SpyRPCService_SubscribeSignedVAAServer) error
|
||||
// SubscribeSignedBatchVAA returns a stream of signed VAA messages, by type, received on the network.
|
||||
SubscribeSignedVAAByType(*SubscribeSignedVAAByTypeRequest, SpyRPCService_SubscribeSignedVAAByTypeServer) error
|
||||
mustEmbedUnimplementedSpyRPCServiceServer()
|
||||
}
|
||||
|
||||
// UnimplementedSpyRPCServiceServer must be embedded to have forward compatible implementations.
|
||||
type UnimplementedSpyRPCServiceServer struct {
|
||||
}
|
||||
|
||||
func (UnimplementedSpyRPCServiceServer) SubscribeSignedVAA(*SubscribeSignedVAARequest, SpyRPCService_SubscribeSignedVAAServer) error {
|
||||
return status.Errorf(codes.Unimplemented, "method SubscribeSignedVAA not implemented")
|
||||
}
|
||||
func (UnimplementedSpyRPCServiceServer) SubscribeSignedVAAByType(*SubscribeSignedVAAByTypeRequest, SpyRPCService_SubscribeSignedVAAByTypeServer) error {
|
||||
return status.Errorf(codes.Unimplemented, "method SubscribeSignedVAAByType not implemented")
|
||||
}
|
||||
func (UnimplementedSpyRPCServiceServer) mustEmbedUnimplementedSpyRPCServiceServer() {}
|
||||
|
||||
// UnsafeSpyRPCServiceServer may be embedded to opt out of forward compatibility for this service.
|
||||
// Use of this interface is not recommended, as added methods to SpyRPCServiceServer will
|
||||
// result in compilation errors.
|
||||
type UnsafeSpyRPCServiceServer interface {
|
||||
mustEmbedUnimplementedSpyRPCServiceServer()
|
||||
}
|
||||
|
||||
func RegisterSpyRPCServiceServer(s grpc.ServiceRegistrar, srv SpyRPCServiceServer) {
|
||||
s.RegisterService(&SpyRPCService_ServiceDesc, srv)
|
||||
}
|
||||
|
||||
func _SpyRPCService_SubscribeSignedVAA_Handler(srv interface{}, stream grpc.ServerStream) error {
|
||||
m := new(SubscribeSignedVAARequest)
|
||||
if err := stream.RecvMsg(m); err != nil {
|
||||
return err
|
||||
}
|
||||
return srv.(SpyRPCServiceServer).SubscribeSignedVAA(m, &spyRPCServiceSubscribeSignedVAAServer{stream})
|
||||
}
|
||||
|
||||
type SpyRPCService_SubscribeSignedVAAServer interface {
|
||||
Send(*SubscribeSignedVAAResponse) error
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
type spyRPCServiceSubscribeSignedVAAServer struct {
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
func (x *spyRPCServiceSubscribeSignedVAAServer) Send(m *SubscribeSignedVAAResponse) error {
|
||||
return x.ServerStream.SendMsg(m)
|
||||
}
|
||||
|
||||
func _SpyRPCService_SubscribeSignedVAAByType_Handler(srv interface{}, stream grpc.ServerStream) error {
|
||||
m := new(SubscribeSignedVAAByTypeRequest)
|
||||
if err := stream.RecvMsg(m); err != nil {
|
||||
return err
|
||||
}
|
||||
return srv.(SpyRPCServiceServer).SubscribeSignedVAAByType(m, &spyRPCServiceSubscribeSignedVAAByTypeServer{stream})
|
||||
}
|
||||
|
||||
type SpyRPCService_SubscribeSignedVAAByTypeServer interface {
|
||||
Send(*SubscribeSignedVAAByTypeResponse) error
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
type spyRPCServiceSubscribeSignedVAAByTypeServer struct {
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
func (x *spyRPCServiceSubscribeSignedVAAByTypeServer) Send(m *SubscribeSignedVAAByTypeResponse) error {
|
||||
return x.ServerStream.SendMsg(m)
|
||||
}
|
||||
|
||||
// SpyRPCService_ServiceDesc is the grpc.ServiceDesc for SpyRPCService service.
|
||||
// It's only intended for direct use with grpc.RegisterService,
|
||||
// and not to be introspected or modified (even as a copy)
|
||||
var SpyRPCService_ServiceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "spy.v1.SpyRPCService",
|
||||
HandlerType: (*SpyRPCServiceServer)(nil),
|
||||
Methods: []grpc.MethodDesc{},
|
||||
Streams: []grpc.StreamDesc{
|
||||
{
|
||||
StreamName: "SubscribeSignedVAA",
|
||||
Handler: _SpyRPCService_SubscribeSignedVAA_Handler,
|
||||
ServerStreams: true,
|
||||
},
|
||||
{
|
||||
StreamName: "SubscribeSignedVAAByType",
|
||||
Handler: _SpyRPCService_SubscribeSignedVAAByType_Handler,
|
||||
ServerStreams: true,
|
||||
},
|
||||
},
|
||||
Metadata: "spy/v1/spy.proto",
|
||||
}
|
|
@ -104,7 +104,7 @@ message GovernanceMessage {
|
|||
// IBC Receiver Integration
|
||||
IbcReceiverUpdateChannelChain ibc_receiver_update_channel_chain = 21;
|
||||
// Wormhole Relayer module
|
||||
WormholeRelayerSetDefaultRelayProvider wormhole_relayer_set_default_relay_provider = 22;
|
||||
WormholeRelayerSetDefaultDeliveryProvider wormhole_relayer_set_default_delivery_provider = 22;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue