geyser_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v3.12.4
// source: geyser.proto

package geyser

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

// GeyserClient is the client API for Geyser 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 GeyserClient interface {
	// Invoke to get the expected heartbeat interval.
	GetHeartbeatInterval(ctx context.Context, in *EmptyRequest, opts ...grpc.CallOption) (*GetHeartbeatIntervalResponse, error)
	// Subscribes to account updates in the accounts database; additionally pings clients with empty heartbeats.
	// Upon initially connecting the client can expect a `highest_write_slot` set in the http headers.
	// Subscribe to account updates
	SubscribeAccountUpdates(ctx context.Context, in *SubscribeAccountUpdatesRequest, opts ...grpc.CallOption) (Geyser_SubscribeAccountUpdatesClient, error)
	// Subscribes to updates given a list of program IDs. When an account update comes in that's owned by a provided
	// program id, one will receive an update
	SubscribeProgramUpdates(ctx context.Context, in *SubscribeProgramsUpdatesRequest, opts ...grpc.CallOption) (Geyser_SubscribeProgramUpdatesClient, error)
	// Functions similarly to `SubscribeAccountUpdates`, but consumes less bandwidth.
	// Returns the highest slot seen thus far in the http headers named `highest-write-slot`.
	SubscribePartialAccountUpdates(ctx context.Context, in *SubscribePartialAccountUpdatesRequest, opts ...grpc.CallOption) (Geyser_SubscribePartialAccountUpdatesClient, error)
	// Subscribes to slot updates.
	// Returns the highest slot seen thus far in the http headers named `highest-write-slot`.
	SubscribeSlotUpdates(ctx context.Context, in *SubscribeSlotUpdateRequest, opts ...grpc.CallOption) (Geyser_SubscribeSlotUpdatesClient, error)
	// Subscribes to transaction updates.
	SubscribeTransactionUpdates(ctx context.Context, in *SubscribeTransactionUpdatesRequest, opts ...grpc.CallOption) (Geyser_SubscribeTransactionUpdatesClient, error)
	// Subscribes to block updates.
	SubscribeBlockUpdates(ctx context.Context, in *SubscribeBlockUpdatesRequest, opts ...grpc.CallOption) (Geyser_SubscribeBlockUpdatesClient, error)
}

type geyserClient struct {
	cc grpc.ClientConnInterface
}

func NewGeyserClient(cc grpc.ClientConnInterface) GeyserClient {
	return &geyserClient{cc}
}

func (c *geyserClient) GetHeartbeatInterval(ctx context.Context, in *EmptyRequest, opts ...grpc.CallOption) (*GetHeartbeatIntervalResponse, error) {
	out := new(GetHeartbeatIntervalResponse)
	err := c.cc.Invoke(ctx, "/solana.geyser.Geyser/GetHeartbeatInterval", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *geyserClient) SubscribeAccountUpdates(ctx context.Context, in *SubscribeAccountUpdatesRequest, opts ...grpc.CallOption) (Geyser_SubscribeAccountUpdatesClient, error) {
	stream, err := c.cc.NewStream(ctx, &Geyser_ServiceDesc.Streams[0], "/solana.geyser.Geyser/SubscribeAccountUpdates", opts...)
	if err != nil {
		return nil, err
	}
	x := &geyserSubscribeAccountUpdatesClient{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 Geyser_SubscribeAccountUpdatesClient interface {
	Recv() (*TimestampedAccountUpdate, error)
	grpc.ClientStream
}

type geyserSubscribeAccountUpdatesClient struct {
	grpc.ClientStream
}

func (x *geyserSubscribeAccountUpdatesClient) Recv() (*TimestampedAccountUpdate, error) {
	m := new(TimestampedAccountUpdate)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *geyserClient) SubscribeProgramUpdates(ctx context.Context, in *SubscribeProgramsUpdatesRequest, opts ...grpc.CallOption) (Geyser_SubscribeProgramUpdatesClient, error) {
	stream, err := c.cc.NewStream(ctx, &Geyser_ServiceDesc.Streams[1], "/solana.geyser.Geyser/SubscribeProgramUpdates", opts...)
	if err != nil {
		return nil, err
	}
	x := &geyserSubscribeProgramUpdatesClient{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 Geyser_SubscribeProgramUpdatesClient interface {
	Recv() (*TimestampedAccountUpdate, error)
	grpc.ClientStream
}

type geyserSubscribeProgramUpdatesClient struct {
	grpc.ClientStream
}

func (x *geyserSubscribeProgramUpdatesClient) Recv() (*TimestampedAccountUpdate, error) {
	m := new(TimestampedAccountUpdate)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *geyserClient) SubscribePartialAccountUpdates(ctx context.Context, in *SubscribePartialAccountUpdatesRequest, opts ...grpc.CallOption) (Geyser_SubscribePartialAccountUpdatesClient, error) {
	stream, err := c.cc.NewStream(ctx, &Geyser_ServiceDesc.Streams[2], "/solana.geyser.Geyser/SubscribePartialAccountUpdates", opts...)
	if err != nil {
		return nil, err
	}
	x := &geyserSubscribePartialAccountUpdatesClient{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 Geyser_SubscribePartialAccountUpdatesClient interface {
	Recv() (*MaybePartialAccountUpdate, error)
	grpc.ClientStream
}

type geyserSubscribePartialAccountUpdatesClient struct {
	grpc.ClientStream
}

func (x *geyserSubscribePartialAccountUpdatesClient) Recv() (*MaybePartialAccountUpdate, error) {
	m := new(MaybePartialAccountUpdate)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *geyserClient) SubscribeSlotUpdates(ctx context.Context, in *SubscribeSlotUpdateRequest, opts ...grpc.CallOption) (Geyser_SubscribeSlotUpdatesClient, error) {
	stream, err := c.cc.NewStream(ctx, &Geyser_ServiceDesc.Streams[3], "/solana.geyser.Geyser/SubscribeSlotUpdates", opts...)
	if err != nil {
		return nil, err
	}
	x := &geyserSubscribeSlotUpdatesClient{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 Geyser_SubscribeSlotUpdatesClient interface {
	Recv() (*TimestampedSlotUpdate, error)
	grpc.ClientStream
}

type geyserSubscribeSlotUpdatesClient struct {
	grpc.ClientStream
}

func (x *geyserSubscribeSlotUpdatesClient) Recv() (*TimestampedSlotUpdate, error) {
	m := new(TimestampedSlotUpdate)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *geyserClient) SubscribeTransactionUpdates(ctx context.Context, in *SubscribeTransactionUpdatesRequest, opts ...grpc.CallOption) (Geyser_SubscribeTransactionUpdatesClient, error) {
	stream, err := c.cc.NewStream(ctx, &Geyser_ServiceDesc.Streams[4], "/solana.geyser.Geyser/SubscribeTransactionUpdates", opts...)
	if err != nil {
		return nil, err
	}
	x := &geyserSubscribeTransactionUpdatesClient{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 Geyser_SubscribeTransactionUpdatesClient interface {
	Recv() (*TimestampedTransactionUpdate, error)
	grpc.ClientStream
}

type geyserSubscribeTransactionUpdatesClient struct {
	grpc.ClientStream
}

func (x *geyserSubscribeTransactionUpdatesClient) Recv() (*TimestampedTransactionUpdate, error) {
	m := new(TimestampedTransactionUpdate)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *geyserClient) SubscribeBlockUpdates(ctx context.Context, in *SubscribeBlockUpdatesRequest, opts ...grpc.CallOption) (Geyser_SubscribeBlockUpdatesClient, error) {
	stream, err := c.cc.NewStream(ctx, &Geyser_ServiceDesc.Streams[5], "/solana.geyser.Geyser/SubscribeBlockUpdates", opts...)
	if err != nil {
		return nil, err
	}
	x := &geyserSubscribeBlockUpdatesClient{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 Geyser_SubscribeBlockUpdatesClient interface {
	Recv() (*TimestampedBlockUpdate, error)
	grpc.ClientStream
}

type geyserSubscribeBlockUpdatesClient struct {
	grpc.ClientStream
}

func (x *geyserSubscribeBlockUpdatesClient) Recv() (*TimestampedBlockUpdate, error) {
	m := new(TimestampedBlockUpdate)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// GeyserServer is the server API for Geyser service.
// All implementations must embed UnimplementedGeyserServer
// for forward compatibility
type GeyserServer interface {
	// Invoke to get the expected heartbeat interval.
	GetHeartbeatInterval(context.Context, *EmptyRequest) (*GetHeartbeatIntervalResponse, error)
	// Subscribes to account updates in the accounts database; additionally pings clients with empty heartbeats.
	// Upon initially connecting the client can expect a `highest_write_slot` set in the http headers.
	// Subscribe to account updates
	SubscribeAccountUpdates(*SubscribeAccountUpdatesRequest, Geyser_SubscribeAccountUpdatesServer) error
	// Subscribes to updates given a list of program IDs. When an account update comes in that's owned by a provided
	// program id, one will receive an update
	SubscribeProgramUpdates(*SubscribeProgramsUpdatesRequest, Geyser_SubscribeProgramUpdatesServer) error
	// Functions similarly to `SubscribeAccountUpdates`, but consumes less bandwidth.
	// Returns the highest slot seen thus far in the http headers named `highest-write-slot`.
	SubscribePartialAccountUpdates(*SubscribePartialAccountUpdatesRequest, Geyser_SubscribePartialAccountUpdatesServer) error
	// Subscribes to slot updates.
	// Returns the highest slot seen thus far in the http headers named `highest-write-slot`.
	SubscribeSlotUpdates(*SubscribeSlotUpdateRequest, Geyser_SubscribeSlotUpdatesServer) error
	// Subscribes to transaction updates.
	SubscribeTransactionUpdates(*SubscribeTransactionUpdatesRequest, Geyser_SubscribeTransactionUpdatesServer) error
	// Subscribes to block updates.
	SubscribeBlockUpdates(*SubscribeBlockUpdatesRequest, Geyser_SubscribeBlockUpdatesServer) error
	mustEmbedUnimplementedGeyserServer()
}

// UnimplementedGeyserServer must be embedded to have forward compatible implementations.
type UnimplementedGeyserServer struct {
}

func (UnimplementedGeyserServer) GetHeartbeatInterval(context.Context, *EmptyRequest) (*GetHeartbeatIntervalResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHeartbeatInterval not implemented")
}
func (UnimplementedGeyserServer) SubscribeAccountUpdates(*SubscribeAccountUpdatesRequest, Geyser_SubscribeAccountUpdatesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeAccountUpdates not implemented")
}
func (UnimplementedGeyserServer) SubscribeProgramUpdates(*SubscribeProgramsUpdatesRequest, Geyser_SubscribeProgramUpdatesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeProgramUpdates not implemented")
}
func (UnimplementedGeyserServer) SubscribePartialAccountUpdates(*SubscribePartialAccountUpdatesRequest, Geyser_SubscribePartialAccountUpdatesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribePartialAccountUpdates not implemented")
}
func (UnimplementedGeyserServer) SubscribeSlotUpdates(*SubscribeSlotUpdateRequest, Geyser_SubscribeSlotUpdatesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeSlotUpdates not implemented")
}
func (UnimplementedGeyserServer) SubscribeTransactionUpdates(*SubscribeTransactionUpdatesRequest, Geyser_SubscribeTransactionUpdatesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeTransactionUpdates not implemented")
}
func (UnimplementedGeyserServer) SubscribeBlockUpdates(*SubscribeBlockUpdatesRequest, Geyser_SubscribeBlockUpdatesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeBlockUpdates not implemented")
}
func (UnimplementedGeyserServer) mustEmbedUnimplementedGeyserServer() {}

// UnsafeGeyserServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to GeyserServer will
// result in compilation errors.
type UnsafeGeyserServer interface {
	mustEmbedUnimplementedGeyserServer()
}

func RegisterGeyserServer(s grpc.ServiceRegistrar, srv GeyserServer) {
	s.RegisterService(&Geyser_ServiceDesc, srv)
}

func _Geyser_GetHeartbeatInterval_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GeyserServer).GetHeartbeatInterval(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/solana.geyser.Geyser/GetHeartbeatInterval",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GeyserServer).GetHeartbeatInterval(ctx, req.(*EmptyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Geyser_SubscribeAccountUpdates_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeAccountUpdatesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GeyserServer).SubscribeAccountUpdates(m, &geyserSubscribeAccountUpdatesServer{stream})
}

type Geyser_SubscribeAccountUpdatesServer interface {
	Send(*TimestampedAccountUpdate) error
	grpc.ServerStream
}

type geyserSubscribeAccountUpdatesServer struct {
	grpc.ServerStream
}

func (x *geyserSubscribeAccountUpdatesServer) Send(m *TimestampedAccountUpdate) error {
	return x.ServerStream.SendMsg(m)
}

func _Geyser_SubscribeProgramUpdates_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeProgramsUpdatesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GeyserServer).SubscribeProgramUpdates(m, &geyserSubscribeProgramUpdatesServer{stream})
}

type Geyser_SubscribeProgramUpdatesServer interface {
	Send(*TimestampedAccountUpdate) error
	grpc.ServerStream
}

type geyserSubscribeProgramUpdatesServer struct {
	grpc.ServerStream
}

func (x *geyserSubscribeProgramUpdatesServer) Send(m *TimestampedAccountUpdate) error {
	return x.ServerStream.SendMsg(m)
}

func _Geyser_SubscribePartialAccountUpdates_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribePartialAccountUpdatesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GeyserServer).SubscribePartialAccountUpdates(m, &geyserSubscribePartialAccountUpdatesServer{stream})
}

type Geyser_SubscribePartialAccountUpdatesServer interface {
	Send(*MaybePartialAccountUpdate) error
	grpc.ServerStream
}

type geyserSubscribePartialAccountUpdatesServer struct {
	grpc.ServerStream
}

func (x *geyserSubscribePartialAccountUpdatesServer) Send(m *MaybePartialAccountUpdate) error {
	return x.ServerStream.SendMsg(m)
}

func _Geyser_SubscribeSlotUpdates_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeSlotUpdateRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GeyserServer).SubscribeSlotUpdates(m, &geyserSubscribeSlotUpdatesServer{stream})
}

type Geyser_SubscribeSlotUpdatesServer interface {
	Send(*TimestampedSlotUpdate) error
	grpc.ServerStream
}

type geyserSubscribeSlotUpdatesServer struct {
	grpc.ServerStream
}

func (x *geyserSubscribeSlotUpdatesServer) Send(m *TimestampedSlotUpdate) error {
	return x.ServerStream.SendMsg(m)
}

func _Geyser_SubscribeTransactionUpdates_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeTransactionUpdatesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GeyserServer).SubscribeTransactionUpdates(m, &geyserSubscribeTransactionUpdatesServer{stream})
}

type Geyser_SubscribeTransactionUpdatesServer interface {
	Send(*TimestampedTransactionUpdate) error
	grpc.ServerStream
}

type geyserSubscribeTransactionUpdatesServer struct {
	grpc.ServerStream
}

func (x *geyserSubscribeTransactionUpdatesServer) Send(m *TimestampedTransactionUpdate) error {
	return x.ServerStream.SendMsg(m)
}

func _Geyser_SubscribeBlockUpdates_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeBlockUpdatesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GeyserServer).SubscribeBlockUpdates(m, &geyserSubscribeBlockUpdatesServer{stream})
}

type Geyser_SubscribeBlockUpdatesServer interface {
	Send(*TimestampedBlockUpdate) error
	grpc.ServerStream
}

type geyserSubscribeBlockUpdatesServer struct {
	grpc.ServerStream
}

func (x *geyserSubscribeBlockUpdatesServer) Send(m *TimestampedBlockUpdate) error {
	return x.ServerStream.SendMsg(m)
}

// Geyser_ServiceDesc is the grpc.ServiceDesc for Geyser service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Geyser_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "solana.geyser.Geyser",
	HandlerType: (*GeyserServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetHeartbeatInterval",
			Handler:    _Geyser_GetHeartbeatInterval_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SubscribeAccountUpdates",
			Handler:       _Geyser_SubscribeAccountUpdates_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeProgramUpdates",
			Handler:       _Geyser_SubscribeProgramUpdates_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribePartialAccountUpdates",
			Handler:       _Geyser_SubscribePartialAccountUpdates_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeSlotUpdates",
			Handler:       _Geyser_SubscribeSlotUpdates_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeTransactionUpdates",
			Handler:       _Geyser_SubscribeTransactionUpdates_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeBlockUpdates",
			Handler:       _Geyser_SubscribeBlockUpdates_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "geyser.proto",
}