certusone
/
wormhole
mirror of https://github.com/certusone/wormhole.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

node: commit proto and matching test fixes #1769

This commit is contained in:
Evan Gray 2022-10-29 00:15:33 +00:00 committed by Evan Gray
parent 9fa943eecd
commit f60e6669ec
13 changed files with 9225 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.github/workflows/build.yml vendored
View File

@ -264,6 +264,11 @@ jobs:
# The go-ethereum and celo-blockchain packages both implement secp256k1 using the exact same header, but that causes duplicate symbols.
- name: Run golang tests
run: cd node && go test -v -race -ldflags '-extldflags "-Wl,--allow-multiple-definition" ' ./...
- name: Ensure generated proto matches
run: |
rm -rf node/pkg/proto
docker build --target go-export -f Dockerfile.proto -o type=local,dest=node .
git diff --name-only --exit-code && echo "✅ Generated proto matches committed proto" || (echo "❌ Generated proto differs from committed proto, run \`rm -rf node/pkg/proto && docker build --target go-export -f Dockerfile.proto -o type=local,dest=node .\` and commit the result" >&2 && exit 1)
# Run Rust lints and tests
rust-lint-and-tests:

26
Tiltfile
View File

@ -90,20 +90,6 @@ if not ci:
def k8s_yaml_with_ns(objects):
return k8s_yaml(namespace_inject(objects, namespace))
# protos
proto_deps = ["./proto", "buf.yaml", "buf.gen.yaml"]
local_resource(
name = "proto-gen",
deps = proto_deps,
cmd = "tilt docker build -- --target go-export -f Dockerfile.proto -o type=local,dest=node .",
env = {"DOCKER_BUILDKIT": "1"},
labels = ["protobuf"],
allow_parallel = True,
trigger_mode = trigger_mode,
)
local_resource(
name = "const-gen",
deps = ["scripts", "clients", "ethereum/.env.test"],
@ -263,7 +249,7 @@ def build_node_yaml():
k8s_yaml_with_ns(build_node_yaml())
guardian_resource_deps = ["proto-gen", "eth-devnet"]
guardian_resource_deps = ["eth-devnet"]
if evm2:
guardian_resource_deps = guardian_resource_deps + ["eth-devnet2"]
if solana:
@ -351,7 +337,7 @@ k8s_yaml_with_ns("devnet/spy.yaml")
k8s_resource(
"spy",
resource_deps = ["proto-gen", "guardian"],
resource_deps = ["guardian"],
port_forwards = [
port_forward(6061, container_port = 6060, name = "Debug/Status Server [:6061]", host = webHost),
port_forward(7072, name = "Spy gRPC [:7072]", host = webHost),
@ -448,7 +434,7 @@ if spy_relayer:
k8s_resource(
"spy-listener",
resource_deps = ["proto-gen", "guardian", "redis", "spy"],
resource_deps = ["guardian", "redis", "spy"],
port_forwards = [
port_forward(6062, container_port = 6060, name = "Debug/Status Server [:6062]", host = webHost),
port_forward(4201, name = "REST [:4201]", host = webHost),
@ -462,7 +448,7 @@ if spy_relayer:
k8s_resource(
"spy-relayer",
resource_deps = ["proto-gen", "guardian", "redis"],
resource_deps = ["guardian", "redis"],
port_forwards = [
port_forward(8083, name = "Prometheus [:8083]", host = webHost),
],
@ -474,7 +460,7 @@ if spy_relayer:
k8s_resource(
"spy-wallet-monitor",
resource_deps = ["proto-gen", "guardian", "redis"],
resource_deps = ["guardian", "redis"],
port_forwards = [
port_forward(8084, name = "Prometheus [:8084]", host = webHost),
],
@ -573,7 +559,7 @@ if explorer:
)
k8s_resource(
"cloud-functions",
resource_deps = ["proto-gen", "bigtable-emulator", "pubsub-emulator"],
resource_deps = ["bigtable-emulator", "pubsub-emulator"],
port_forwards = [port_forward(8090, name = "Cloud Functions [:8090]", host = webHost)],
labels = ["explorer"],
trigger_mode = trigger_mode,

1
node/pkg/.gitignore vendored
View File

@ -1 +0,0 @@
proto

2011
node/pkg/proto/gossip/v1/gossip.pb.go Normal file
View File

File diff suppressed because it is too large Load Diff

2032
node/pkg/proto/node/v1/node.pb.go Normal file
View File

File diff suppressed because it is too large Load Diff

815
node/pkg/proto/node/v1/node.pb.gw.go Normal file
View File

@ -0,0 +1,815 @@
// 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
}
// 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()...)
})
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()...)
})
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"}, ""))
)
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
)

429
node/pkg/proto/node/v1/node_grpc.pb.go Normal file
View File

@ -0,0 +1,429 @@
// 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)
}
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
}
// 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)
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) 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)
}
// 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,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "node/v1/node.proto",
}

1986
node/pkg/proto/publicrpc/v1/publicrpc.pb.go Normal file
View File

File diff suppressed because it is too large Load Diff

910
node/pkg/proto/publicrpc/v1/publicrpc.pb.gw.go Normal file
View File

@ -0,0 +1,910 @@
// 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}, Base: []int{1, 1, 1, 2, 0, 0}, Check: []int{0, 1, 2, 2, 3, 4}}
)
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)
}
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)
}
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}"))
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}"))
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}, []string{"v1", "signed_batch_vaa", "batch_id.emitter_chain", "batch_id.tx_id"}, ""))
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
)

359
node/pkg/proto/publicrpc/v1/publicrpc_grpc.pb.go Normal file
View File

@ -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",
}

400
node/pkg/proto/spy/v1/spy.pb.go Normal file
View File

@ -0,0 +1,400 @@
// 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 (
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 FilterEntry struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Types that are assignable to Filter:
// *FilterEntry_EmitterFilter
Filter isFilterEntry_Filter `protobuf_oneof:"filter"`
}
func (x *FilterEntry) Reset() {
*x = FilterEntry{}
if protoimpl.UnsafeEnabled {
mi := &file_spy_v1_spy_proto_msgTypes[1]
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[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 FilterEntry.ProtoReflect.Descriptor instead.
func (*FilterEntry) Descriptor() ([]byte, []int) {
return file_spy_v1_spy_proto_rawDescGZIP(), []int{1}
}
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
}
type isFilterEntry_Filter interface {
isFilterEntry_Filter()
}
type FilterEntry_EmitterFilter struct {
EmitterFilter *EmitterFilter `protobuf:"bytes,1,opt,name=emitter_filter,json=emitterFilter,proto3,oneof"`
}
func (*FilterEntry_EmitterFilter) 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[2]
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[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 SubscribeSignedVAARequest.ProtoReflect.Descriptor instead.
func (*SubscribeSignedVAARequest) Descriptor() ([]byte, []int) {
return file_spy_v1_spy_proto_rawDescGZIP(), []int{2}
}
func (x *SubscribeSignedVAARequest) 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[3]
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[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 SubscribeSignedVAAResponse.ProtoReflect.Descriptor instead.
func (*SubscribeSignedVAAResponse) Descriptor() ([]byte, []int) {
return file_spy_v1_spy_proto_rawDescGZIP(), []int{3}
}
func (x *SubscribeSignedVAAResponse) GetVaaBytes() []byte {
if x != nil {
return x.VaaBytes
}
return nil
}
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, 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, 0x57, 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, 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, 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, 0x32, 0x94, 0x01, 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, 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, 4)
var file_spy_v1_spy_proto_goTypes = []interface{}{
(*EmitterFilter)(nil), // 0: spy.v1.EmitterFilter
(*FilterEntry)(nil), // 1: spy.v1.FilterEntry
(*SubscribeSignedVAARequest)(nil), // 2: spy.v1.SubscribeSignedVAARequest
(*SubscribeSignedVAAResponse)(nil), // 3: spy.v1.SubscribeSignedVAAResponse
(v1.ChainID)(0), // 4: publicrpc.v1.ChainID
}
var file_spy_v1_spy_proto_depIdxs = []int32{
4, // 0: spy.v1.EmitterFilter.chain_id:type_name -> publicrpc.v1.ChainID
0, // 1: spy.v1.FilterEntry.emitter_filter:type_name -> spy.v1.EmitterFilter
1, // 2: spy.v1.SubscribeSignedVAARequest.filters:type_name -> spy.v1.FilterEntry
2, // 3: spy.v1.SpyRPCService.SubscribeSignedVAA:input_type -> spy.v1.SubscribeSignedVAARequest
3, // 4: spy.v1.SpyRPCService.SubscribeSignedVAA:output_type -> spy.v1.SubscribeSignedVAAResponse
4, // [4:5] is the sub-list for method output_type
3, // [3:4] is the sub-list for method input_type
3, // [3:3] is the sub-list for extension type_name
3, // [3:3] is the sub-list for extension extendee
0, // [0:3] 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.(*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[2].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[3].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[1].OneofWrappers = []interface{}{
(*FilterEntry_EmitterFilter)(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: 4,
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
}

142
node/pkg/proto/spy/v1/spy.pb.gw.go Normal file
View File

@ -0,0 +1,142 @@
// 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
}
// 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
})
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()...)
})
return nil
}
var (
pattern_SpyRPCService_SubscribeSignedVAA_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"v1"}, "subscribe_signed_vaa"))
)
var (
forward_SpyRPCService_SubscribeSignedVAA_0 = runtime.ForwardResponseStream
)

130
node/pkg/proto/spy/v1/spy_grpc.pb.go Normal file
View File

@ -0,0 +1,130 @@
// 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)
}
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
}
// 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
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) 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)
}
// 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,
},
},
Metadata: "spy/v1/spy.proto",
}