1 files changed, 551 insertions, 0 deletions

diff --git a/api/nostr/v1/nostr_grpc.pb.go b/api/nostr/v1/nostr_grpc.pb.go
new file mode 100644
index 0000000..fba3f79
--- /dev/null
+++ b/api/nostr/v1/nostr_grpc.pb.go
@@ -0,0 +1,551 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.6.1
+// - protoc             (unknown)
+// source: nostr/v1/nostr.proto
+
+package nostrv1
+
+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.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+        NostrRelay_PublishEvent_FullMethodName = "/nostr.v1.NostrRelay/PublishEvent"
+        NostrRelay_Subscribe_FullMethodName    = "/nostr.v1.NostrRelay/Subscribe"
+        NostrRelay_Unsubscribe_FullMethodName  = "/nostr.v1.NostrRelay/Unsubscribe"
+        NostrRelay_PublishBatch_FullMethodName = "/nostr.v1.NostrRelay/PublishBatch"
+        NostrRelay_QueryEvents_FullMethodName  = "/nostr.v1.NostrRelay/QueryEvents"
+        NostrRelay_CountEvents_FullMethodName  = "/nostr.v1.NostrRelay/CountEvents"
+)
+
+// NostrRelayClient is the client API for NostrRelay 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.
+//
+// Main relay service
+type NostrRelayClient interface {
+        // Publish a single event
+        PublishEvent(ctx context.Context, in *PublishEventRequest, opts ...grpc.CallOption) (*PublishEventResponse, error)
+        // Subscribe to events matching filters (streaming)
+        Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Event], error)
+        // Unsubscribe from an active subscription
+        Unsubscribe(ctx context.Context, in *UnsubscribeRequest, opts ...grpc.CallOption) (*Empty, error)
+        // gRPC-specific: batch publish
+        PublishBatch(ctx context.Context, in *PublishBatchRequest, opts ...grpc.CallOption) (*PublishBatchResponse, error)
+        // gRPC-specific: paginated query (non-streaming)
+        QueryEvents(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResponse, error)
+        // Event counts (NIP-45)
+        CountEvents(ctx context.Context, in *CountRequest, opts ...grpc.CallOption) (*CountResponse, error)
+}
+
+type nostrRelayClient struct {
+        cc grpc.ClientConnInterface
+}
+
+func NewNostrRelayClient(cc grpc.ClientConnInterface) NostrRelayClient {
+        return &nostrRelayClient{cc}
+}
+
+func (c *nostrRelayClient) PublishEvent(ctx context.Context, in *PublishEventRequest, opts ...grpc.CallOption) (*PublishEventResponse, error) {
+        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+        out := new(PublishEventResponse)
+        err := c.cc.Invoke(ctx, NostrRelay_PublishEvent_FullMethodName, in, out, cOpts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+func (c *nostrRelayClient) Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Event], error) {
+        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+        stream, err := c.cc.NewStream(ctx, &NostrRelay_ServiceDesc.Streams[0], NostrRelay_Subscribe_FullMethodName, cOpts...)
+        if err != nil {
+                return nil, err
+        }
+        x := &grpc.GenericClientStream[SubscribeRequest, Event]{ClientStream: 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
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type NostrRelay_SubscribeClient = grpc.ServerStreamingClient[Event]
+
+func (c *nostrRelayClient) Unsubscribe(ctx context.Context, in *UnsubscribeRequest, opts ...grpc.CallOption) (*Empty, error) {
+        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+        out := new(Empty)
+        err := c.cc.Invoke(ctx, NostrRelay_Unsubscribe_FullMethodName, in, out, cOpts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+func (c *nostrRelayClient) PublishBatch(ctx context.Context, in *PublishBatchRequest, opts ...grpc.CallOption) (*PublishBatchResponse, error) {
+        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+        out := new(PublishBatchResponse)
+        err := c.cc.Invoke(ctx, NostrRelay_PublishBatch_FullMethodName, in, out, cOpts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+func (c *nostrRelayClient) QueryEvents(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResponse, error) {
+        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+        out := new(QueryResponse)
+        err := c.cc.Invoke(ctx, NostrRelay_QueryEvents_FullMethodName, in, out, cOpts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+func (c *nostrRelayClient) CountEvents(ctx context.Context, in *CountRequest, opts ...grpc.CallOption) (*CountResponse, error) {
+        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+        out := new(CountResponse)
+        err := c.cc.Invoke(ctx, NostrRelay_CountEvents_FullMethodName, in, out, cOpts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+// NostrRelayServer is the server API for NostrRelay service.
+// All implementations must embed UnimplementedNostrRelayServer
+// for forward compatibility.
+//
+// Main relay service
+type NostrRelayServer interface {
+        // Publish a single event
+        PublishEvent(context.Context, *PublishEventRequest) (*PublishEventResponse, error)
+        // Subscribe to events matching filters (streaming)
+        Subscribe(*SubscribeRequest, grpc.ServerStreamingServer[Event]) error
+        // Unsubscribe from an active subscription
+        Unsubscribe(context.Context, *UnsubscribeRequest) (*Empty, error)
+        // gRPC-specific: batch publish
+        PublishBatch(context.Context, *PublishBatchRequest) (*PublishBatchResponse, error)
+        // gRPC-specific: paginated query (non-streaming)
+        QueryEvents(context.Context, *QueryRequest) (*QueryResponse, error)
+        // Event counts (NIP-45)
+        CountEvents(context.Context, *CountRequest) (*CountResponse, error)
+        mustEmbedUnimplementedNostrRelayServer()
+}
+
+// UnimplementedNostrRelayServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedNostrRelayServer struct{}
+
+func (UnimplementedNostrRelayServer) PublishEvent(context.Context, *PublishEventRequest) (*PublishEventResponse, error) {
+        return nil, status.Error(codes.Unimplemented, "method PublishEvent not implemented")
+}
+func (UnimplementedNostrRelayServer) Subscribe(*SubscribeRequest, grpc.ServerStreamingServer[Event]) error {
+        return status.Error(codes.Unimplemented, "method Subscribe not implemented")
+}
+func (UnimplementedNostrRelayServer) Unsubscribe(context.Context, *UnsubscribeRequest) (*Empty, error) {
+        return nil, status.Error(codes.Unimplemented, "method Unsubscribe not implemented")
+}
+func (UnimplementedNostrRelayServer) PublishBatch(context.Context, *PublishBatchRequest) (*PublishBatchResponse, error) {
+        return nil, status.Error(codes.Unimplemented, "method PublishBatch not implemented")
+}
+func (UnimplementedNostrRelayServer) QueryEvents(context.Context, *QueryRequest) (*QueryResponse, error) {
+        return nil, status.Error(codes.Unimplemented, "method QueryEvents not implemented")
+}
+func (UnimplementedNostrRelayServer) CountEvents(context.Context, *CountRequest) (*CountResponse, error) {
+        return nil, status.Error(codes.Unimplemented, "method CountEvents not implemented")
+}
+func (UnimplementedNostrRelayServer) mustEmbedUnimplementedNostrRelayServer() {}
+func (UnimplementedNostrRelayServer) testEmbeddedByValue()                    {}
+
+// UnsafeNostrRelayServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to NostrRelayServer will
+// result in compilation errors.
+type UnsafeNostrRelayServer interface {
+        mustEmbedUnimplementedNostrRelayServer()
+}
+
+func RegisterNostrRelayServer(s grpc.ServiceRegistrar, srv NostrRelayServer) {
+        // If the following call panics, it indicates UnimplementedNostrRelayServer was
+        // embedded by pointer and is nil.  This will cause panics if an
+        // unimplemented method is ever invoked, so we test this at initialization
+        // time to prevent it from happening at runtime later due to I/O.
+        if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+                t.testEmbeddedByValue()
+        }
+        s.RegisterService(&NostrRelay_ServiceDesc, srv)
+}
+
+func _NostrRelay_PublishEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(PublishEventRequest)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(NostrRelayServer).PublishEvent(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: NostrRelay_PublishEvent_FullMethodName,
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(NostrRelayServer).PublishEvent(ctx, req.(*PublishEventRequest))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+func _NostrRelay_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
+        m := new(SubscribeRequest)
+        if err := stream.RecvMsg(m); err != nil {
+                return err
+        }
+        return srv.(NostrRelayServer).Subscribe(m, &grpc.GenericServerStream[SubscribeRequest, Event]{ServerStream: stream})
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type NostrRelay_SubscribeServer = grpc.ServerStreamingServer[Event]
+
+func _NostrRelay_Unsubscribe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(UnsubscribeRequest)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(NostrRelayServer).Unsubscribe(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: NostrRelay_Unsubscribe_FullMethodName,
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(NostrRelayServer).Unsubscribe(ctx, req.(*UnsubscribeRequest))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+func _NostrRelay_PublishBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(PublishBatchRequest)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(NostrRelayServer).PublishBatch(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: NostrRelay_PublishBatch_FullMethodName,
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(NostrRelayServer).PublishBatch(ctx, req.(*PublishBatchRequest))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+func _NostrRelay_QueryEvents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(QueryRequest)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(NostrRelayServer).QueryEvents(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: NostrRelay_QueryEvents_FullMethodName,
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(NostrRelayServer).QueryEvents(ctx, req.(*QueryRequest))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+func _NostrRelay_CountEvents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(CountRequest)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(NostrRelayServer).CountEvents(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: NostrRelay_CountEvents_FullMethodName,
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(NostrRelayServer).CountEvents(ctx, req.(*CountRequest))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+// NostrRelay_ServiceDesc is the grpc.ServiceDesc for NostrRelay service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var NostrRelay_ServiceDesc = grpc.ServiceDesc{
+        ServiceName: "nostr.v1.NostrRelay",
+        HandlerType: (*NostrRelayServer)(nil),
+        Methods: []grpc.MethodDesc{
+                {
+                        MethodName: "PublishEvent",
+                        Handler:    _NostrRelay_PublishEvent_Handler,
+                },
+                {
+                        MethodName: "Unsubscribe",
+                        Handler:    _NostrRelay_Unsubscribe_Handler,
+                },
+                {
+                        MethodName: "PublishBatch",
+                        Handler:    _NostrRelay_PublishBatch_Handler,
+                },
+                {
+                        MethodName: "QueryEvents",
+                        Handler:    _NostrRelay_QueryEvents_Handler,
+                },
+                {
+                        MethodName: "CountEvents",
+                        Handler:    _NostrRelay_CountEvents_Handler,
+                },
+        },
+        Streams: []grpc.StreamDesc{
+                {
+                        StreamName:    "Subscribe",
+                        Handler:       _NostrRelay_Subscribe_Handler,
+                        ServerStreams: true,
+                },
+        },
+        Metadata: "nostr/v1/nostr.proto",
+}
+
+const (
+        RelayAdmin_GetStats_FullMethodName       = "/nostr.v1.RelayAdmin/GetStats"
+        RelayAdmin_GetConnections_FullMethodName = "/nostr.v1.RelayAdmin/GetConnections"
+        RelayAdmin_BanPublicKey_FullMethodName   = "/nostr.v1.RelayAdmin/BanPublicKey"
+        RelayAdmin_GetStorageInfo_FullMethodName = "/nostr.v1.RelayAdmin/GetStorageInfo"
+)
+
+// RelayAdminClient is the client API for RelayAdmin 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.
+//
+// Admin service (optional, secured separately)
+type RelayAdminClient interface {
+        GetStats(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*RelayStats, error)
+        GetConnections(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ConnectionList, error)
+        BanPublicKey(ctx context.Context, in *BanRequest, opts ...grpc.CallOption) (*Empty, error)
+        GetStorageInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*StorageStats, error)
+}
+
+type relayAdminClient struct {
+        cc grpc.ClientConnInterface
+}
+
+func NewRelayAdminClient(cc grpc.ClientConnInterface) RelayAdminClient {
+        return &relayAdminClient{cc}
+}
+
+func (c *relayAdminClient) GetStats(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*RelayStats, error) {
+        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+        out := new(RelayStats)
+        err := c.cc.Invoke(ctx, RelayAdmin_GetStats_FullMethodName, in, out, cOpts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+func (c *relayAdminClient) GetConnections(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ConnectionList, error) {
+        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+        out := new(ConnectionList)
+        err := c.cc.Invoke(ctx, RelayAdmin_GetConnections_FullMethodName, in, out, cOpts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+func (c *relayAdminClient) BanPublicKey(ctx context.Context, in *BanRequest, opts ...grpc.CallOption) (*Empty, error) {
+        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+        out := new(Empty)
+        err := c.cc.Invoke(ctx, RelayAdmin_BanPublicKey_FullMethodName, in, out, cOpts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+func (c *relayAdminClient) GetStorageInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*StorageStats, error) {
+        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+        out := new(StorageStats)
+        err := c.cc.Invoke(ctx, RelayAdmin_GetStorageInfo_FullMethodName, in, out, cOpts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+// RelayAdminServer is the server API for RelayAdmin service.
+// All implementations must embed UnimplementedRelayAdminServer
+// for forward compatibility.
+//
+// Admin service (optional, secured separately)
+type RelayAdminServer interface {
+        GetStats(context.Context, *Empty) (*RelayStats, error)
+        GetConnections(context.Context, *Empty) (*ConnectionList, error)
+        BanPublicKey(context.Context, *BanRequest) (*Empty, error)
+        GetStorageInfo(context.Context, *Empty) (*StorageStats, error)
+        mustEmbedUnimplementedRelayAdminServer()
+}
+
+// UnimplementedRelayAdminServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedRelayAdminServer struct{}
+
+func (UnimplementedRelayAdminServer) GetStats(context.Context, *Empty) (*RelayStats, error) {
+        return nil, status.Error(codes.Unimplemented, "method GetStats not implemented")
+}
+func (UnimplementedRelayAdminServer) GetConnections(context.Context, *Empty) (*ConnectionList, error) {
+        return nil, status.Error(codes.Unimplemented, "method GetConnections not implemented")
+}
+func (UnimplementedRelayAdminServer) BanPublicKey(context.Context, *BanRequest) (*Empty, error) {
+        return nil, status.Error(codes.Unimplemented, "method BanPublicKey not implemented")
+}
+func (UnimplementedRelayAdminServer) GetStorageInfo(context.Context, *Empty) (*StorageStats, error) {
+        return nil, status.Error(codes.Unimplemented, "method GetStorageInfo not implemented")
+}
+func (UnimplementedRelayAdminServer) mustEmbedUnimplementedRelayAdminServer() {}
+func (UnimplementedRelayAdminServer) testEmbeddedByValue()                    {}
+
+// UnsafeRelayAdminServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to RelayAdminServer will
+// result in compilation errors.
+type UnsafeRelayAdminServer interface {
+        mustEmbedUnimplementedRelayAdminServer()
+}
+
+func RegisterRelayAdminServer(s grpc.ServiceRegistrar, srv RelayAdminServer) {
+        // If the following call panics, it indicates UnimplementedRelayAdminServer was
+        // embedded by pointer and is nil.  This will cause panics if an
+        // unimplemented method is ever invoked, so we test this at initialization
+        // time to prevent it from happening at runtime later due to I/O.
+        if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+                t.testEmbeddedByValue()
+        }
+        s.RegisterService(&RelayAdmin_ServiceDesc, srv)
+}
+
+func _RelayAdmin_GetStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(Empty)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(RelayAdminServer).GetStats(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: RelayAdmin_GetStats_FullMethodName,
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(RelayAdminServer).GetStats(ctx, req.(*Empty))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+func _RelayAdmin_GetConnections_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(Empty)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(RelayAdminServer).GetConnections(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: RelayAdmin_GetConnections_FullMethodName,
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(RelayAdminServer).GetConnections(ctx, req.(*Empty))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+func _RelayAdmin_BanPublicKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(BanRequest)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(RelayAdminServer).BanPublicKey(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: RelayAdmin_BanPublicKey_FullMethodName,
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(RelayAdminServer).BanPublicKey(ctx, req.(*BanRequest))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+func _RelayAdmin_GetStorageInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(Empty)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(RelayAdminServer).GetStorageInfo(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: RelayAdmin_GetStorageInfo_FullMethodName,
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(RelayAdminServer).GetStorageInfo(ctx, req.(*Empty))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+// RelayAdmin_ServiceDesc is the grpc.ServiceDesc for RelayAdmin service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var RelayAdmin_ServiceDesc = grpc.ServiceDesc{
+        ServiceName: "nostr.v1.RelayAdmin",
+        HandlerType: (*RelayAdminServer)(nil),
+        Methods: []grpc.MethodDesc{
+                {
+                        MethodName: "GetStats",
+                        Handler:    _RelayAdmin_GetStats_Handler,
+                },
+                {
+                        MethodName: "GetConnections",
+                        Handler:    _RelayAdmin_GetConnections_Handler,
+                },
+                {
+                        MethodName: "BanPublicKey",
+                        Handler:    _RelayAdmin_BanPublicKey_Handler,
+                },
+                {
+                        MethodName: "GetStorageInfo",
+                        Handler:    _RelayAdmin_GetStorageInfo_Handler,
+                },
+        },
+        Streams:  []grpc.StreamDesc{},
+        Metadata: "nostr/v1/nostr.proto",
+}