From 9d834eebe10fb857f077d4a3dfb310c55be1124b Mon Sep 17 00:00:00 2001 From: dhruvsol Date: Sun, 30 Nov 2025 10:13:01 +0530 Subject: [PATCH 1/6] wip: setup basic geyser streaming interface --- pkg/grpc/geyser_service.go | 180 ++ pkg/grpc/grpc.go | 42 + pkg/grpc/grpc_test.go | 124 ++ pkg/grpc/pb/geyser.pb.go | 3203 ++++++++++++++++++++++++++++++ pkg/grpc/pb/geyser.proto | 279 +++ pkg/grpc/pb/geyser_grpc.pb.go | 382 ++++ pkg/grpc/pb/solana-storage.pb.go | 1559 +++++++++++++++ pkg/grpc/pb/solana-storage.proto | 151 ++ 8 files changed, 5920 insertions(+) create mode 100644 pkg/grpc/geyser_service.go create mode 100644 pkg/grpc/grpc.go create mode 100644 pkg/grpc/grpc_test.go create mode 100644 pkg/grpc/pb/geyser.pb.go create mode 100644 pkg/grpc/pb/geyser.proto create mode 100644 pkg/grpc/pb/geyser_grpc.pb.go create mode 100644 pkg/grpc/pb/solana-storage.pb.go create mode 100644 pkg/grpc/pb/solana-storage.proto diff --git a/pkg/grpc/geyser_service.go b/pkg/grpc/geyser_service.go new file mode 100644 index 00000000..30948c4f --- /dev/null +++ b/pkg/grpc/geyser_service.go @@ -0,0 +1,180 @@ +package grpc + +import ( + "context" + "slices" + + "github.com/Overclock-Validator/mithril/pkg/grpc/pb" + "google.golang.org/grpc" +) + +type GeyserService struct { + pb.UnimplementedGeyserServer + + // Channel for receiving SubscribeUpdate messages that need to be filtered and sent + updateChan chan *pb.SubscribeUpdate +} + + +func NewGeyserService() *GeyserService { + return &GeyserService{ + updateChan: make(chan *pb.SubscribeUpdate, 100), + } +} + +// GetUpdateChannel returns the channel where SubscribeUpdate messages can be sent +// External code can send messages to this channel, and they will be filtered and forwarded +func (s *GeyserService) GetUpdateChannel() chan<- *pb.SubscribeUpdate { + return s.updateChan +} + +func (s *GeyserService) Ping(ctx context.Context, req *pb.PingRequest) (*pb.PongResponse, error) { + return &pb.PongResponse{ + Count: req.Count, + }, nil +} + +func (s *GeyserService) Subscribe(stream grpc.BidiStreamingServer[pb.SubscribeRequest, pb.SubscribeUpdate]) error { + ctx := stream.Context() + + // Channel for receiving SubscribeRequest messages from the client + requestChan := make(chan *pb.SubscribeRequest, 10) + + // Channel for sending SubscribeUpdate messages to the client + updateChan := make(chan *pb.SubscribeUpdate, 100) + + // Channel to signal when we're done + done := make(chan error, 1) + + // Goroutine to receive SubscribeRequest messages from the client + go func() { + for { + req, err := stream.Recv() + if err != nil { + done <- err + close(requestChan) + return + } + requestChan <- req + } + }() + + // Goroutine to send SubscribeUpdate messages to the client + go func() { + for { + select { + case update := <-updateChan: + if err := stream.Send(update); err != nil { + done <- err + return + } + case <-ctx.Done(): + done <- ctx.Err() + return + } + } + }() + + // Main loop: process requests and filter updates + var activeRequest *pb.SubscribeRequest + + for { + select { + case req, ok := <-requestChan: + if !ok { + // Client closed the request stream + return nil + } + + // Handle ping/pong + if req.Ping != nil { + filterIDs := s.extractFilterIDs(activeRequest) + pong := &pb.SubscribeUpdate{ + Filters: filterIDs, + UpdateOneof: &pb.SubscribeUpdate_Pong{ + Pong: &pb.SubscribeUpdatePong{ + Id: req.Ping.Id, + }, + }, + } + select { + case updateChan <- pong: + case <-ctx.Done(): + return ctx.Err() + } + continue + } + + activeRequest = req + + case update := <-s.updateChan: + if s.shouldSendUpdate(update, activeRequest) { + if activeRequest != nil { + update.Filters = s.extractFilterIDs(activeRequest) + } + select { + case updateChan <- update: + case <-ctx.Done(): + return ctx.Err() + } + } + + case err := <-done: + return err + + case <-ctx.Done(): + return ctx.Err() + } + } +} + +func (s *GeyserService) extractFilterIDs(req *pb.SubscribeRequest) []string { + var filterIDs []string + + if req != nil && len(req.Blocks) > 0 { + for id := range req.Blocks { + filterIDs = append(filterIDs, id) + } + } + + return filterIDs +} + +func (s *GeyserService) shouldSendUpdate(update *pb.SubscribeUpdate, req *pb.SubscribeRequest) bool { + if req == nil { + return true + } + + // Always send ping/pong messages + switch update.UpdateOneof.(type) { + case *pb.SubscribeUpdate_Ping, *pb.SubscribeUpdate_Pong: + return true + case *pb.SubscribeUpdate_Block: + return s.matchesBlockFilter(update.GetBlock(), req) + default: + return false + } +} + +func (s *GeyserService) matchesBlockFilter(block *pb.SubscribeUpdateBlock, req *pb.SubscribeRequest) bool { + if len(req.Blocks) == 0 { + return false + } + + for _, filter := range req.Blocks { + if len(filter.AccountInclude) > 0 { + accounts := block.GetAccounts() + + for _, account := range accounts { + if slices.Contains(filter.AccountInclude, string(account.Pubkey)) { + return true + } + } + + // TODO build other filters here + return false + } + } + + return true +} diff --git a/pkg/grpc/grpc.go b/pkg/grpc/grpc.go new file mode 100644 index 00000000..d7b21c76 --- /dev/null +++ b/pkg/grpc/grpc.go @@ -0,0 +1,42 @@ +package grpc + +import ( + "fmt" + "log" + "net" + + "github.com/Overclock-Validator/mithril/pkg/grpc/pb" + "google.golang.org/grpc" +) + +type GrpcServer struct { + server *grpc.Server + listener net.Listener + port uint16 + geyserService *GeyserService +} + +func NewGrpcServer(port uint16, opts []grpc.ServerOption) *GrpcServer { + lis, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", port)) + if err != nil { + log.Fatalf("failed to listen: %v", err) + } + server := grpc.NewServer(opts...) + + return &GrpcServer{ + port: port, + listener: lis, + server: server, + geyserService: NewGeyserService(), + } +} + +func (s *GrpcServer) Start() error { + pb.RegisterGeyserServer(s.server, s.geyserService) + return s.server.Serve(s.listener) +} + +func (s *GrpcServer) GracefulStop() { + s.server.GracefulStop() +} + diff --git a/pkg/grpc/grpc_test.go b/pkg/grpc/grpc_test.go new file mode 100644 index 00000000..835c1dd2 --- /dev/null +++ b/pkg/grpc/grpc_test.go @@ -0,0 +1,124 @@ +package grpc + +import ( + "context" + "fmt" + "testing" + "time" + + "github.com/Overclock-Validator/mithril/pkg/grpc/pb" + "google.golang.org/grpc" + "google.golang.org/grpc/credentials/insecure" +) + +func TestGrpcServer(t *testing.T) { + // Use a test port + port := uint16(50052) + + // Create a new gRPC server + server := NewGrpcServer(port, nil) + + // Start server in a goroutine + errChan := make(chan error, 1) + go func() { + errChan <- server.Start() + }() + + // Give the server a moment to start + time.Sleep(100 * time.Millisecond) + + // Try to connect to the server to verify it's running + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + + conn, err := grpc.NewClient( + fmt.Sprintf("localhost:%d", port), + grpc.WithTransportCredentials(insecure.NewCredentials()), + ) + if err != nil { + t.Fatalf("Failed to connect to server: %v", err) + } + defer conn.Close() + + // Verify connection is ready + if !conn.WaitForStateChange(ctx, conn.GetState()) { + t.Log("Connection state changed (server is running)") + } + + // Stop the server + server.server.Stop() + + // Wait for server to stop + select { + case err := <-errChan: + if err != nil && err != grpc.ErrServerStopped { + t.Logf("Server stopped with error: %v", err) + } + case <-time.After(2 * time.Second): + t.Log("Server stopped") + } +} + +func TestPingPong(t *testing.T) { + // Use a test port + port := uint16(50053) + + // Create a new gRPC server (Geyser service is automatically created and registered) + server := NewGrpcServer(port, nil) + + // Start server in a goroutine + errChan := make(chan error, 1) + go func() { + errChan <- server.Start() + }() + + // Give the server a moment to start + time.Sleep(100 * time.Millisecond) + + // Connect to the server + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + + conn, err := grpc.NewClient( + fmt.Sprintf("localhost:%d", port), + grpc.WithTransportCredentials(insecure.NewCredentials()), + ) + if err != nil { + t.Fatalf("Failed to connect to server: %v", err) + } + defer conn.Close() + + // Create Geyser client + client := pb.NewGeyserClient(conn) + + // Test Ping with count = 42 + pingReq := &pb.PingRequest{ + Count: 42, + } + + pongResp, err := client.Ping(ctx, pingReq) + if err != nil { + t.Fatalf("Ping failed: %v", err) + } + + // Verify the response + if pongResp.Count != 42 { + t.Errorf("Expected count 42, got %d", pongResp.Count) + } + + t.Logf("Ping/Pong successful: sent count=%d, received count=%d", pingReq.Count, pongResp.Count) + + // Stop the server + server.server.Stop() + + // Wait for server to stop + select { + case err := <-errChan: + if err != nil && err != grpc.ErrServerStopped { + t.Logf("Server stopped with error: %v", err) + } + case <-time.After(2 * time.Second): + t.Log("Server stopped") + } +} + diff --git a/pkg/grpc/pb/geyser.pb.go b/pkg/grpc/pb/geyser.pb.go new file mode 100644 index 00000000..1ac569ad --- /dev/null +++ b/pkg/grpc/pb/geyser.pb.go @@ -0,0 +1,3203 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.10 +// protoc v5.28.0 +// source: geyser.proto + +package pb + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +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) +) + +type CommitmentLevel int32 + +const ( + CommitmentLevel_PROCESSED CommitmentLevel = 0 + CommitmentLevel_CONFIRMED CommitmentLevel = 1 + CommitmentLevel_FINALIZED CommitmentLevel = 2 +) + +// Enum value maps for CommitmentLevel. +var ( + CommitmentLevel_name = map[int32]string{ + 0: "PROCESSED", + 1: "CONFIRMED", + 2: "FINALIZED", + } + CommitmentLevel_value = map[string]int32{ + "PROCESSED": 0, + "CONFIRMED": 1, + "FINALIZED": 2, + } +) + +func (x CommitmentLevel) Enum() *CommitmentLevel { + p := new(CommitmentLevel) + *p = x + return p +} + +func (x CommitmentLevel) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (CommitmentLevel) Descriptor() protoreflect.EnumDescriptor { + return file_geyser_proto_enumTypes[0].Descriptor() +} + +func (CommitmentLevel) Type() protoreflect.EnumType { + return &file_geyser_proto_enumTypes[0] +} + +func (x CommitmentLevel) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use CommitmentLevel.Descriptor instead. +func (CommitmentLevel) EnumDescriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{0} +} + +type SlotStatus int32 + +const ( + SlotStatus_SLOT_PROCESSED SlotStatus = 0 + SlotStatus_SLOT_CONFIRMED SlotStatus = 1 + SlotStatus_SLOT_FINALIZED SlotStatus = 2 + SlotStatus_SLOT_FIRST_SHRED_RECEIVED SlotStatus = 3 + SlotStatus_SLOT_COMPLETED SlotStatus = 4 + SlotStatus_SLOT_CREATED_BANK SlotStatus = 5 + SlotStatus_SLOT_DEAD SlotStatus = 6 +) + +// Enum value maps for SlotStatus. +var ( + SlotStatus_name = map[int32]string{ + 0: "SLOT_PROCESSED", + 1: "SLOT_CONFIRMED", + 2: "SLOT_FINALIZED", + 3: "SLOT_FIRST_SHRED_RECEIVED", + 4: "SLOT_COMPLETED", + 5: "SLOT_CREATED_BANK", + 6: "SLOT_DEAD", + } + SlotStatus_value = map[string]int32{ + "SLOT_PROCESSED": 0, + "SLOT_CONFIRMED": 1, + "SLOT_FINALIZED": 2, + "SLOT_FIRST_SHRED_RECEIVED": 3, + "SLOT_COMPLETED": 4, + "SLOT_CREATED_BANK": 5, + "SLOT_DEAD": 6, + } +) + +func (x SlotStatus) Enum() *SlotStatus { + p := new(SlotStatus) + *p = x + return p +} + +func (x SlotStatus) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SlotStatus) Descriptor() protoreflect.EnumDescriptor { + return file_geyser_proto_enumTypes[1].Descriptor() +} + +func (SlotStatus) Type() protoreflect.EnumType { + return &file_geyser_proto_enumTypes[1] +} + +func (x SlotStatus) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SlotStatus.Descriptor instead. +func (SlotStatus) EnumDescriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{1} +} + +type SubscribeRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Accounts map[string]*SubscribeRequestFilterAccounts `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Slots map[string]*SubscribeRequestFilterSlots `protobuf:"bytes,2,rep,name=slots,proto3" json:"slots,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Transactions map[string]*SubscribeRequestFilterTransactions `protobuf:"bytes,3,rep,name=transactions,proto3" json:"transactions,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + TransactionsStatus map[string]*SubscribeRequestFilterTransactions `protobuf:"bytes,10,rep,name=transactions_status,json=transactionsStatus,proto3" json:"transactions_status,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Blocks map[string]*SubscribeRequestFilterBlocks `protobuf:"bytes,4,rep,name=blocks,proto3" json:"blocks,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + BlocksMeta map[string]*SubscribeRequestFilterBlocksMeta `protobuf:"bytes,5,rep,name=blocks_meta,json=blocksMeta,proto3" json:"blocks_meta,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Entry map[string]*SubscribeRequestFilterEntry `protobuf:"bytes,8,rep,name=entry,proto3" json:"entry,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Commitment *CommitmentLevel `protobuf:"varint,6,opt,name=commitment,proto3,enum=geyser.CommitmentLevel,oneof" json:"commitment,omitempty"` + AccountsDataSlice []*SubscribeRequestAccountsDataSlice `protobuf:"bytes,7,rep,name=accounts_data_slice,json=accountsDataSlice,proto3" json:"accounts_data_slice,omitempty"` + Ping *SubscribeRequestPing `protobuf:"bytes,9,opt,name=ping,proto3,oneof" json:"ping,omitempty"` + FromSlot *uint64 `protobuf:"varint,11,opt,name=from_slot,json=fromSlot,proto3,oneof" json:"from_slot,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequest) Reset() { + *x = SubscribeRequest{} + mi := &file_geyser_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequest) ProtoMessage() {} + +func (x *SubscribeRequest) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequest.ProtoReflect.Descriptor instead. +func (*SubscribeRequest) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{0} +} + +func (x *SubscribeRequest) GetAccounts() map[string]*SubscribeRequestFilterAccounts { + if x != nil { + return x.Accounts + } + return nil +} + +func (x *SubscribeRequest) GetSlots() map[string]*SubscribeRequestFilterSlots { + if x != nil { + return x.Slots + } + return nil +} + +func (x *SubscribeRequest) GetTransactions() map[string]*SubscribeRequestFilterTransactions { + if x != nil { + return x.Transactions + } + return nil +} + +func (x *SubscribeRequest) GetTransactionsStatus() map[string]*SubscribeRequestFilterTransactions { + if x != nil { + return x.TransactionsStatus + } + return nil +} + +func (x *SubscribeRequest) GetBlocks() map[string]*SubscribeRequestFilterBlocks { + if x != nil { + return x.Blocks + } + return nil +} + +func (x *SubscribeRequest) GetBlocksMeta() map[string]*SubscribeRequestFilterBlocksMeta { + if x != nil { + return x.BlocksMeta + } + return nil +} + +func (x *SubscribeRequest) GetEntry() map[string]*SubscribeRequestFilterEntry { + if x != nil { + return x.Entry + } + return nil +} + +func (x *SubscribeRequest) GetCommitment() CommitmentLevel { + if x != nil && x.Commitment != nil { + return *x.Commitment + } + return CommitmentLevel_PROCESSED +} + +func (x *SubscribeRequest) GetAccountsDataSlice() []*SubscribeRequestAccountsDataSlice { + if x != nil { + return x.AccountsDataSlice + } + return nil +} + +func (x *SubscribeRequest) GetPing() *SubscribeRequestPing { + if x != nil { + return x.Ping + } + return nil +} + +func (x *SubscribeRequest) GetFromSlot() uint64 { + if x != nil && x.FromSlot != nil { + return *x.FromSlot + } + return 0 +} + +type SubscribeRequestFilterAccounts struct { + state protoimpl.MessageState `protogen:"open.v1"` + Account []string `protobuf:"bytes,2,rep,name=account,proto3" json:"account,omitempty"` + Owner []string `protobuf:"bytes,3,rep,name=owner,proto3" json:"owner,omitempty"` + Filters []*SubscribeRequestFilterAccountsFilter `protobuf:"bytes,4,rep,name=filters,proto3" json:"filters,omitempty"` + NonemptyTxnSignature *bool `protobuf:"varint,5,opt,name=nonempty_txn_signature,json=nonemptyTxnSignature,proto3,oneof" json:"nonempty_txn_signature,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequestFilterAccounts) Reset() { + *x = SubscribeRequestFilterAccounts{} + mi := &file_geyser_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequestFilterAccounts) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequestFilterAccounts) ProtoMessage() {} + +func (x *SubscribeRequestFilterAccounts) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequestFilterAccounts.ProtoReflect.Descriptor instead. +func (*SubscribeRequestFilterAccounts) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{1} +} + +func (x *SubscribeRequestFilterAccounts) GetAccount() []string { + if x != nil { + return x.Account + } + return nil +} + +func (x *SubscribeRequestFilterAccounts) GetOwner() []string { + if x != nil { + return x.Owner + } + return nil +} + +func (x *SubscribeRequestFilterAccounts) GetFilters() []*SubscribeRequestFilterAccountsFilter { + if x != nil { + return x.Filters + } + return nil +} + +func (x *SubscribeRequestFilterAccounts) GetNonemptyTxnSignature() bool { + if x != nil && x.NonemptyTxnSignature != nil { + return *x.NonemptyTxnSignature + } + return false +} + +type SubscribeRequestFilterAccountsFilter struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Filter: + // + // *SubscribeRequestFilterAccountsFilter_Memcmp + // *SubscribeRequestFilterAccountsFilter_Datasize + // *SubscribeRequestFilterAccountsFilter_TokenAccountState + // *SubscribeRequestFilterAccountsFilter_Lamports + Filter isSubscribeRequestFilterAccountsFilter_Filter `protobuf_oneof:"filter"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequestFilterAccountsFilter) Reset() { + *x = SubscribeRequestFilterAccountsFilter{} + mi := &file_geyser_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequestFilterAccountsFilter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequestFilterAccountsFilter) ProtoMessage() {} + +func (x *SubscribeRequestFilterAccountsFilter) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequestFilterAccountsFilter.ProtoReflect.Descriptor instead. +func (*SubscribeRequestFilterAccountsFilter) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{2} +} + +func (x *SubscribeRequestFilterAccountsFilter) GetFilter() isSubscribeRequestFilterAccountsFilter_Filter { + if x != nil { + return x.Filter + } + return nil +} + +func (x *SubscribeRequestFilterAccountsFilter) GetMemcmp() *SubscribeRequestFilterAccountsFilterMemcmp { + if x != nil { + if x, ok := x.Filter.(*SubscribeRequestFilterAccountsFilter_Memcmp); ok { + return x.Memcmp + } + } + return nil +} + +func (x *SubscribeRequestFilterAccountsFilter) GetDatasize() uint64 { + if x != nil { + if x, ok := x.Filter.(*SubscribeRequestFilterAccountsFilter_Datasize); ok { + return x.Datasize + } + } + return 0 +} + +func (x *SubscribeRequestFilterAccountsFilter) GetTokenAccountState() bool { + if x != nil { + if x, ok := x.Filter.(*SubscribeRequestFilterAccountsFilter_TokenAccountState); ok { + return x.TokenAccountState + } + } + return false +} + +func (x *SubscribeRequestFilterAccountsFilter) GetLamports() *SubscribeRequestFilterAccountsFilterLamports { + if x != nil { + if x, ok := x.Filter.(*SubscribeRequestFilterAccountsFilter_Lamports); ok { + return x.Lamports + } + } + return nil +} + +type isSubscribeRequestFilterAccountsFilter_Filter interface { + isSubscribeRequestFilterAccountsFilter_Filter() +} + +type SubscribeRequestFilterAccountsFilter_Memcmp struct { + Memcmp *SubscribeRequestFilterAccountsFilterMemcmp `protobuf:"bytes,1,opt,name=memcmp,proto3,oneof"` +} + +type SubscribeRequestFilterAccountsFilter_Datasize struct { + Datasize uint64 `protobuf:"varint,2,opt,name=datasize,proto3,oneof"` +} + +type SubscribeRequestFilterAccountsFilter_TokenAccountState struct { + TokenAccountState bool `protobuf:"varint,3,opt,name=token_account_state,json=tokenAccountState,proto3,oneof"` +} + +type SubscribeRequestFilterAccountsFilter_Lamports struct { + Lamports *SubscribeRequestFilterAccountsFilterLamports `protobuf:"bytes,4,opt,name=lamports,proto3,oneof"` +} + +func (*SubscribeRequestFilterAccountsFilter_Memcmp) isSubscribeRequestFilterAccountsFilter_Filter() {} + +func (*SubscribeRequestFilterAccountsFilter_Datasize) isSubscribeRequestFilterAccountsFilter_Filter() { +} + +func (*SubscribeRequestFilterAccountsFilter_TokenAccountState) isSubscribeRequestFilterAccountsFilter_Filter() { +} + +func (*SubscribeRequestFilterAccountsFilter_Lamports) isSubscribeRequestFilterAccountsFilter_Filter() { +} + +type SubscribeRequestFilterAccountsFilterMemcmp struct { + state protoimpl.MessageState `protogen:"open.v1"` + Offset uint64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"` + // Types that are valid to be assigned to Data: + // + // *SubscribeRequestFilterAccountsFilterMemcmp_Bytes + // *SubscribeRequestFilterAccountsFilterMemcmp_Base58 + // *SubscribeRequestFilterAccountsFilterMemcmp_Base64 + Data isSubscribeRequestFilterAccountsFilterMemcmp_Data `protobuf_oneof:"data"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequestFilterAccountsFilterMemcmp) Reset() { + *x = SubscribeRequestFilterAccountsFilterMemcmp{} + mi := &file_geyser_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequestFilterAccountsFilterMemcmp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequestFilterAccountsFilterMemcmp) ProtoMessage() {} + +func (x *SubscribeRequestFilterAccountsFilterMemcmp) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequestFilterAccountsFilterMemcmp.ProtoReflect.Descriptor instead. +func (*SubscribeRequestFilterAccountsFilterMemcmp) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{3} +} + +func (x *SubscribeRequestFilterAccountsFilterMemcmp) GetOffset() uint64 { + if x != nil { + return x.Offset + } + return 0 +} + +func (x *SubscribeRequestFilterAccountsFilterMemcmp) GetData() isSubscribeRequestFilterAccountsFilterMemcmp_Data { + if x != nil { + return x.Data + } + return nil +} + +func (x *SubscribeRequestFilterAccountsFilterMemcmp) GetBytes() []byte { + if x != nil { + if x, ok := x.Data.(*SubscribeRequestFilterAccountsFilterMemcmp_Bytes); ok { + return x.Bytes + } + } + return nil +} + +func (x *SubscribeRequestFilterAccountsFilterMemcmp) GetBase58() string { + if x != nil { + if x, ok := x.Data.(*SubscribeRequestFilterAccountsFilterMemcmp_Base58); ok { + return x.Base58 + } + } + return "" +} + +func (x *SubscribeRequestFilterAccountsFilterMemcmp) GetBase64() string { + if x != nil { + if x, ok := x.Data.(*SubscribeRequestFilterAccountsFilterMemcmp_Base64); ok { + return x.Base64 + } + } + return "" +} + +type isSubscribeRequestFilterAccountsFilterMemcmp_Data interface { + isSubscribeRequestFilterAccountsFilterMemcmp_Data() +} + +type SubscribeRequestFilterAccountsFilterMemcmp_Bytes struct { + Bytes []byte `protobuf:"bytes,2,opt,name=bytes,proto3,oneof"` +} + +type SubscribeRequestFilterAccountsFilterMemcmp_Base58 struct { + Base58 string `protobuf:"bytes,3,opt,name=base58,proto3,oneof"` +} + +type SubscribeRequestFilterAccountsFilterMemcmp_Base64 struct { + Base64 string `protobuf:"bytes,4,opt,name=base64,proto3,oneof"` +} + +func (*SubscribeRequestFilterAccountsFilterMemcmp_Bytes) isSubscribeRequestFilterAccountsFilterMemcmp_Data() { +} + +func (*SubscribeRequestFilterAccountsFilterMemcmp_Base58) isSubscribeRequestFilterAccountsFilterMemcmp_Data() { +} + +func (*SubscribeRequestFilterAccountsFilterMemcmp_Base64) isSubscribeRequestFilterAccountsFilterMemcmp_Data() { +} + +type SubscribeRequestFilterAccountsFilterLamports struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Cmp: + // + // *SubscribeRequestFilterAccountsFilterLamports_Eq + // *SubscribeRequestFilterAccountsFilterLamports_Ne + // *SubscribeRequestFilterAccountsFilterLamports_Lt + // *SubscribeRequestFilterAccountsFilterLamports_Gt + Cmp isSubscribeRequestFilterAccountsFilterLamports_Cmp `protobuf_oneof:"cmp"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequestFilterAccountsFilterLamports) Reset() { + *x = SubscribeRequestFilterAccountsFilterLamports{} + mi := &file_geyser_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequestFilterAccountsFilterLamports) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequestFilterAccountsFilterLamports) ProtoMessage() {} + +func (x *SubscribeRequestFilterAccountsFilterLamports) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequestFilterAccountsFilterLamports.ProtoReflect.Descriptor instead. +func (*SubscribeRequestFilterAccountsFilterLamports) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{4} +} + +func (x *SubscribeRequestFilterAccountsFilterLamports) GetCmp() isSubscribeRequestFilterAccountsFilterLamports_Cmp { + if x != nil { + return x.Cmp + } + return nil +} + +func (x *SubscribeRequestFilterAccountsFilterLamports) GetEq() uint64 { + if x != nil { + if x, ok := x.Cmp.(*SubscribeRequestFilterAccountsFilterLamports_Eq); ok { + return x.Eq + } + } + return 0 +} + +func (x *SubscribeRequestFilterAccountsFilterLamports) GetNe() uint64 { + if x != nil { + if x, ok := x.Cmp.(*SubscribeRequestFilterAccountsFilterLamports_Ne); ok { + return x.Ne + } + } + return 0 +} + +func (x *SubscribeRequestFilterAccountsFilterLamports) GetLt() uint64 { + if x != nil { + if x, ok := x.Cmp.(*SubscribeRequestFilterAccountsFilterLamports_Lt); ok { + return x.Lt + } + } + return 0 +} + +func (x *SubscribeRequestFilterAccountsFilterLamports) GetGt() uint64 { + if x != nil { + if x, ok := x.Cmp.(*SubscribeRequestFilterAccountsFilterLamports_Gt); ok { + return x.Gt + } + } + return 0 +} + +type isSubscribeRequestFilterAccountsFilterLamports_Cmp interface { + isSubscribeRequestFilterAccountsFilterLamports_Cmp() +} + +type SubscribeRequestFilterAccountsFilterLamports_Eq struct { + Eq uint64 `protobuf:"varint,1,opt,name=eq,proto3,oneof"` +} + +type SubscribeRequestFilterAccountsFilterLamports_Ne struct { + Ne uint64 `protobuf:"varint,2,opt,name=ne,proto3,oneof"` +} + +type SubscribeRequestFilterAccountsFilterLamports_Lt struct { + Lt uint64 `protobuf:"varint,3,opt,name=lt,proto3,oneof"` +} + +type SubscribeRequestFilterAccountsFilterLamports_Gt struct { + Gt uint64 `protobuf:"varint,4,opt,name=gt,proto3,oneof"` +} + +func (*SubscribeRequestFilterAccountsFilterLamports_Eq) isSubscribeRequestFilterAccountsFilterLamports_Cmp() { +} + +func (*SubscribeRequestFilterAccountsFilterLamports_Ne) isSubscribeRequestFilterAccountsFilterLamports_Cmp() { +} + +func (*SubscribeRequestFilterAccountsFilterLamports_Lt) isSubscribeRequestFilterAccountsFilterLamports_Cmp() { +} + +func (*SubscribeRequestFilterAccountsFilterLamports_Gt) isSubscribeRequestFilterAccountsFilterLamports_Cmp() { +} + +type SubscribeRequestFilterSlots struct { + state protoimpl.MessageState `protogen:"open.v1"` + FilterByCommitment *bool `protobuf:"varint,1,opt,name=filter_by_commitment,json=filterByCommitment,proto3,oneof" json:"filter_by_commitment,omitempty"` + InterslotUpdates *bool `protobuf:"varint,2,opt,name=interslot_updates,json=interslotUpdates,proto3,oneof" json:"interslot_updates,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequestFilterSlots) Reset() { + *x = SubscribeRequestFilterSlots{} + mi := &file_geyser_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequestFilterSlots) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequestFilterSlots) ProtoMessage() {} + +func (x *SubscribeRequestFilterSlots) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequestFilterSlots.ProtoReflect.Descriptor instead. +func (*SubscribeRequestFilterSlots) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{5} +} + +func (x *SubscribeRequestFilterSlots) GetFilterByCommitment() bool { + if x != nil && x.FilterByCommitment != nil { + return *x.FilterByCommitment + } + return false +} + +func (x *SubscribeRequestFilterSlots) GetInterslotUpdates() bool { + if x != nil && x.InterslotUpdates != nil { + return *x.InterslotUpdates + } + return false +} + +type SubscribeRequestFilterTransactions struct { + state protoimpl.MessageState `protogen:"open.v1"` + Vote *bool `protobuf:"varint,1,opt,name=vote,proto3,oneof" json:"vote,omitempty"` + Failed *bool `protobuf:"varint,2,opt,name=failed,proto3,oneof" json:"failed,omitempty"` + Signature *string `protobuf:"bytes,5,opt,name=signature,proto3,oneof" json:"signature,omitempty"` + AccountInclude []string `protobuf:"bytes,3,rep,name=account_include,json=accountInclude,proto3" json:"account_include,omitempty"` + AccountExclude []string `protobuf:"bytes,4,rep,name=account_exclude,json=accountExclude,proto3" json:"account_exclude,omitempty"` + AccountRequired []string `protobuf:"bytes,6,rep,name=account_required,json=accountRequired,proto3" json:"account_required,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequestFilterTransactions) Reset() { + *x = SubscribeRequestFilterTransactions{} + mi := &file_geyser_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequestFilterTransactions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequestFilterTransactions) ProtoMessage() {} + +func (x *SubscribeRequestFilterTransactions) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequestFilterTransactions.ProtoReflect.Descriptor instead. +func (*SubscribeRequestFilterTransactions) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{6} +} + +func (x *SubscribeRequestFilterTransactions) GetVote() bool { + if x != nil && x.Vote != nil { + return *x.Vote + } + return false +} + +func (x *SubscribeRequestFilterTransactions) GetFailed() bool { + if x != nil && x.Failed != nil { + return *x.Failed + } + return false +} + +func (x *SubscribeRequestFilterTransactions) GetSignature() string { + if x != nil && x.Signature != nil { + return *x.Signature + } + return "" +} + +func (x *SubscribeRequestFilterTransactions) GetAccountInclude() []string { + if x != nil { + return x.AccountInclude + } + return nil +} + +func (x *SubscribeRequestFilterTransactions) GetAccountExclude() []string { + if x != nil { + return x.AccountExclude + } + return nil +} + +func (x *SubscribeRequestFilterTransactions) GetAccountRequired() []string { + if x != nil { + return x.AccountRequired + } + return nil +} + +type SubscribeRequestFilterBlocks struct { + state protoimpl.MessageState `protogen:"open.v1"` + AccountInclude []string `protobuf:"bytes,1,rep,name=account_include,json=accountInclude,proto3" json:"account_include,omitempty"` + IncludeTransactions *bool `protobuf:"varint,2,opt,name=include_transactions,json=includeTransactions,proto3,oneof" json:"include_transactions,omitempty"` + IncludeAccounts *bool `protobuf:"varint,3,opt,name=include_accounts,json=includeAccounts,proto3,oneof" json:"include_accounts,omitempty"` + IncludeEntries *bool `protobuf:"varint,4,opt,name=include_entries,json=includeEntries,proto3,oneof" json:"include_entries,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequestFilterBlocks) Reset() { + *x = SubscribeRequestFilterBlocks{} + mi := &file_geyser_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequestFilterBlocks) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequestFilterBlocks) ProtoMessage() {} + +func (x *SubscribeRequestFilterBlocks) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequestFilterBlocks.ProtoReflect.Descriptor instead. +func (*SubscribeRequestFilterBlocks) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{7} +} + +func (x *SubscribeRequestFilterBlocks) GetAccountInclude() []string { + if x != nil { + return x.AccountInclude + } + return nil +} + +func (x *SubscribeRequestFilterBlocks) GetIncludeTransactions() bool { + if x != nil && x.IncludeTransactions != nil { + return *x.IncludeTransactions + } + return false +} + +func (x *SubscribeRequestFilterBlocks) GetIncludeAccounts() bool { + if x != nil && x.IncludeAccounts != nil { + return *x.IncludeAccounts + } + return false +} + +func (x *SubscribeRequestFilterBlocks) GetIncludeEntries() bool { + if x != nil && x.IncludeEntries != nil { + return *x.IncludeEntries + } + return false +} + +type SubscribeRequestFilterBlocksMeta struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequestFilterBlocksMeta) Reset() { + *x = SubscribeRequestFilterBlocksMeta{} + mi := &file_geyser_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequestFilterBlocksMeta) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequestFilterBlocksMeta) ProtoMessage() {} + +func (x *SubscribeRequestFilterBlocksMeta) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequestFilterBlocksMeta.ProtoReflect.Descriptor instead. +func (*SubscribeRequestFilterBlocksMeta) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{8} +} + +type SubscribeRequestFilterEntry struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequestFilterEntry) Reset() { + *x = SubscribeRequestFilterEntry{} + mi := &file_geyser_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequestFilterEntry) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequestFilterEntry) ProtoMessage() {} + +func (x *SubscribeRequestFilterEntry) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequestFilterEntry.ProtoReflect.Descriptor instead. +func (*SubscribeRequestFilterEntry) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{9} +} + +type SubscribeRequestAccountsDataSlice struct { + state protoimpl.MessageState `protogen:"open.v1"` + Offset uint64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"` + Length uint64 `protobuf:"varint,2,opt,name=length,proto3" json:"length,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequestAccountsDataSlice) Reset() { + *x = SubscribeRequestAccountsDataSlice{} + mi := &file_geyser_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequestAccountsDataSlice) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequestAccountsDataSlice) ProtoMessage() {} + +func (x *SubscribeRequestAccountsDataSlice) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequestAccountsDataSlice.ProtoReflect.Descriptor instead. +func (*SubscribeRequestAccountsDataSlice) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{10} +} + +func (x *SubscribeRequestAccountsDataSlice) GetOffset() uint64 { + if x != nil { + return x.Offset + } + return 0 +} + +func (x *SubscribeRequestAccountsDataSlice) GetLength() uint64 { + if x != nil { + return x.Length + } + return 0 +} + +type SubscribeRequestPing struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeRequestPing) Reset() { + *x = SubscribeRequestPing{} + mi := &file_geyser_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeRequestPing) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeRequestPing) ProtoMessage() {} + +func (x *SubscribeRequestPing) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeRequestPing.ProtoReflect.Descriptor instead. +func (*SubscribeRequestPing) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{11} +} + +func (x *SubscribeRequestPing) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +type SubscribeUpdate struct { + state protoimpl.MessageState `protogen:"open.v1"` + Filters []string `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"` + // Types that are valid to be assigned to UpdateOneof: + // + // *SubscribeUpdate_Account + // *SubscribeUpdate_Slot + // *SubscribeUpdate_Transaction + // *SubscribeUpdate_TransactionStatus + // *SubscribeUpdate_Block + // *SubscribeUpdate_Ping + // *SubscribeUpdate_Pong + // *SubscribeUpdate_BlockMeta + // *SubscribeUpdate_Entry + UpdateOneof isSubscribeUpdate_UpdateOneof `protobuf_oneof:"update_oneof"` + CreatedAt *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdate) Reset() { + *x = SubscribeUpdate{} + mi := &file_geyser_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdate) ProtoMessage() {} + +func (x *SubscribeUpdate) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdate.ProtoReflect.Descriptor instead. +func (*SubscribeUpdate) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{12} +} + +func (x *SubscribeUpdate) GetFilters() []string { + if x != nil { + return x.Filters + } + return nil +} + +func (x *SubscribeUpdate) GetUpdateOneof() isSubscribeUpdate_UpdateOneof { + if x != nil { + return x.UpdateOneof + } + return nil +} + +func (x *SubscribeUpdate) GetAccount() *SubscribeUpdateAccount { + if x != nil { + if x, ok := x.UpdateOneof.(*SubscribeUpdate_Account); ok { + return x.Account + } + } + return nil +} + +func (x *SubscribeUpdate) GetSlot() *SubscribeUpdateSlot { + if x != nil { + if x, ok := x.UpdateOneof.(*SubscribeUpdate_Slot); ok { + return x.Slot + } + } + return nil +} + +func (x *SubscribeUpdate) GetTransaction() *SubscribeUpdateTransaction { + if x != nil { + if x, ok := x.UpdateOneof.(*SubscribeUpdate_Transaction); ok { + return x.Transaction + } + } + return nil +} + +func (x *SubscribeUpdate) GetTransactionStatus() *SubscribeUpdateTransactionStatus { + if x != nil { + if x, ok := x.UpdateOneof.(*SubscribeUpdate_TransactionStatus); ok { + return x.TransactionStatus + } + } + return nil +} + +func (x *SubscribeUpdate) GetBlock() *SubscribeUpdateBlock { + if x != nil { + if x, ok := x.UpdateOneof.(*SubscribeUpdate_Block); ok { + return x.Block + } + } + return nil +} + +func (x *SubscribeUpdate) GetPing() *SubscribeUpdatePing { + if x != nil { + if x, ok := x.UpdateOneof.(*SubscribeUpdate_Ping); ok { + return x.Ping + } + } + return nil +} + +func (x *SubscribeUpdate) GetPong() *SubscribeUpdatePong { + if x != nil { + if x, ok := x.UpdateOneof.(*SubscribeUpdate_Pong); ok { + return x.Pong + } + } + return nil +} + +func (x *SubscribeUpdate) GetBlockMeta() *SubscribeUpdateBlockMeta { + if x != nil { + if x, ok := x.UpdateOneof.(*SubscribeUpdate_BlockMeta); ok { + return x.BlockMeta + } + } + return nil +} + +func (x *SubscribeUpdate) GetEntry() *SubscribeUpdateEntry { + if x != nil { + if x, ok := x.UpdateOneof.(*SubscribeUpdate_Entry); ok { + return x.Entry + } + } + return nil +} + +func (x *SubscribeUpdate) GetCreatedAt() *timestamppb.Timestamp { + if x != nil { + return x.CreatedAt + } + return nil +} + +type isSubscribeUpdate_UpdateOneof interface { + isSubscribeUpdate_UpdateOneof() +} + +type SubscribeUpdate_Account struct { + Account *SubscribeUpdateAccount `protobuf:"bytes,2,opt,name=account,proto3,oneof"` +} + +type SubscribeUpdate_Slot struct { + Slot *SubscribeUpdateSlot `protobuf:"bytes,3,opt,name=slot,proto3,oneof"` +} + +type SubscribeUpdate_Transaction struct { + Transaction *SubscribeUpdateTransaction `protobuf:"bytes,4,opt,name=transaction,proto3,oneof"` +} + +type SubscribeUpdate_TransactionStatus struct { + TransactionStatus *SubscribeUpdateTransactionStatus `protobuf:"bytes,10,opt,name=transaction_status,json=transactionStatus,proto3,oneof"` +} + +type SubscribeUpdate_Block struct { + Block *SubscribeUpdateBlock `protobuf:"bytes,5,opt,name=block,proto3,oneof"` +} + +type SubscribeUpdate_Ping struct { + Ping *SubscribeUpdatePing `protobuf:"bytes,6,opt,name=ping,proto3,oneof"` +} + +type SubscribeUpdate_Pong struct { + Pong *SubscribeUpdatePong `protobuf:"bytes,9,opt,name=pong,proto3,oneof"` +} + +type SubscribeUpdate_BlockMeta struct { + BlockMeta *SubscribeUpdateBlockMeta `protobuf:"bytes,7,opt,name=block_meta,json=blockMeta,proto3,oneof"` +} + +type SubscribeUpdate_Entry struct { + Entry *SubscribeUpdateEntry `protobuf:"bytes,8,opt,name=entry,proto3,oneof"` +} + +func (*SubscribeUpdate_Account) isSubscribeUpdate_UpdateOneof() {} + +func (*SubscribeUpdate_Slot) isSubscribeUpdate_UpdateOneof() {} + +func (*SubscribeUpdate_Transaction) isSubscribeUpdate_UpdateOneof() {} + +func (*SubscribeUpdate_TransactionStatus) isSubscribeUpdate_UpdateOneof() {} + +func (*SubscribeUpdate_Block) isSubscribeUpdate_UpdateOneof() {} + +func (*SubscribeUpdate_Ping) isSubscribeUpdate_UpdateOneof() {} + +func (*SubscribeUpdate_Pong) isSubscribeUpdate_UpdateOneof() {} + +func (*SubscribeUpdate_BlockMeta) isSubscribeUpdate_UpdateOneof() {} + +func (*SubscribeUpdate_Entry) isSubscribeUpdate_UpdateOneof() {} + +type SubscribeUpdateAccount struct { + state protoimpl.MessageState `protogen:"open.v1"` + Account *SubscribeUpdateAccountInfo `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"` + Slot uint64 `protobuf:"varint,2,opt,name=slot,proto3" json:"slot,omitempty"` + IsStartup bool `protobuf:"varint,3,opt,name=is_startup,json=isStartup,proto3" json:"is_startup,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdateAccount) Reset() { + *x = SubscribeUpdateAccount{} + mi := &file_geyser_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdateAccount) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdateAccount) ProtoMessage() {} + +func (x *SubscribeUpdateAccount) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdateAccount.ProtoReflect.Descriptor instead. +func (*SubscribeUpdateAccount) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{13} +} + +func (x *SubscribeUpdateAccount) GetAccount() *SubscribeUpdateAccountInfo { + if x != nil { + return x.Account + } + return nil +} + +func (x *SubscribeUpdateAccount) GetSlot() uint64 { + if x != nil { + return x.Slot + } + return 0 +} + +func (x *SubscribeUpdateAccount) GetIsStartup() bool { + if x != nil { + return x.IsStartup + } + return false +} + +type SubscribeUpdateAccountInfo struct { + state protoimpl.MessageState `protogen:"open.v1"` + Pubkey []byte `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"` + Lamports uint64 `protobuf:"varint,2,opt,name=lamports,proto3" json:"lamports,omitempty"` + Owner []byte `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"` + Executable bool `protobuf:"varint,4,opt,name=executable,proto3" json:"executable,omitempty"` + RentEpoch uint64 `protobuf:"varint,5,opt,name=rent_epoch,json=rentEpoch,proto3" json:"rent_epoch,omitempty"` + Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"` + WriteVersion uint64 `protobuf:"varint,7,opt,name=write_version,json=writeVersion,proto3" json:"write_version,omitempty"` + TxnSignature []byte `protobuf:"bytes,8,opt,name=txn_signature,json=txnSignature,proto3,oneof" json:"txn_signature,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdateAccountInfo) Reset() { + *x = SubscribeUpdateAccountInfo{} + mi := &file_geyser_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdateAccountInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdateAccountInfo) ProtoMessage() {} + +func (x *SubscribeUpdateAccountInfo) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdateAccountInfo.ProtoReflect.Descriptor instead. +func (*SubscribeUpdateAccountInfo) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{14} +} + +func (x *SubscribeUpdateAccountInfo) GetPubkey() []byte { + if x != nil { + return x.Pubkey + } + return nil +} + +func (x *SubscribeUpdateAccountInfo) GetLamports() uint64 { + if x != nil { + return x.Lamports + } + return 0 +} + +func (x *SubscribeUpdateAccountInfo) GetOwner() []byte { + if x != nil { + return x.Owner + } + return nil +} + +func (x *SubscribeUpdateAccountInfo) GetExecutable() bool { + if x != nil { + return x.Executable + } + return false +} + +func (x *SubscribeUpdateAccountInfo) GetRentEpoch() uint64 { + if x != nil { + return x.RentEpoch + } + return 0 +} + +func (x *SubscribeUpdateAccountInfo) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *SubscribeUpdateAccountInfo) GetWriteVersion() uint64 { + if x != nil { + return x.WriteVersion + } + return 0 +} + +func (x *SubscribeUpdateAccountInfo) GetTxnSignature() []byte { + if x != nil { + return x.TxnSignature + } + return nil +} + +type SubscribeUpdateSlot struct { + state protoimpl.MessageState `protogen:"open.v1"` + Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` + Parent *uint64 `protobuf:"varint,2,opt,name=parent,proto3,oneof" json:"parent,omitempty"` + Status SlotStatus `protobuf:"varint,3,opt,name=status,proto3,enum=geyser.SlotStatus" json:"status,omitempty"` + DeadError *string `protobuf:"bytes,4,opt,name=dead_error,json=deadError,proto3,oneof" json:"dead_error,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdateSlot) Reset() { + *x = SubscribeUpdateSlot{} + mi := &file_geyser_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdateSlot) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdateSlot) ProtoMessage() {} + +func (x *SubscribeUpdateSlot) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[15] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdateSlot.ProtoReflect.Descriptor instead. +func (*SubscribeUpdateSlot) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{15} +} + +func (x *SubscribeUpdateSlot) GetSlot() uint64 { + if x != nil { + return x.Slot + } + return 0 +} + +func (x *SubscribeUpdateSlot) GetParent() uint64 { + if x != nil && x.Parent != nil { + return *x.Parent + } + return 0 +} + +func (x *SubscribeUpdateSlot) GetStatus() SlotStatus { + if x != nil { + return x.Status + } + return SlotStatus_SLOT_PROCESSED +} + +func (x *SubscribeUpdateSlot) GetDeadError() string { + if x != nil && x.DeadError != nil { + return *x.DeadError + } + return "" +} + +type SubscribeUpdateTransaction struct { + state protoimpl.MessageState `protogen:"open.v1"` + Transaction *SubscribeUpdateTransactionInfo `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"` + Slot uint64 `protobuf:"varint,2,opt,name=slot,proto3" json:"slot,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdateTransaction) Reset() { + *x = SubscribeUpdateTransaction{} + mi := &file_geyser_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdateTransaction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdateTransaction) ProtoMessage() {} + +func (x *SubscribeUpdateTransaction) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[16] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdateTransaction.ProtoReflect.Descriptor instead. +func (*SubscribeUpdateTransaction) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{16} +} + +func (x *SubscribeUpdateTransaction) GetTransaction() *SubscribeUpdateTransactionInfo { + if x != nil { + return x.Transaction + } + return nil +} + +func (x *SubscribeUpdateTransaction) GetSlot() uint64 { + if x != nil { + return x.Slot + } + return 0 +} + +type SubscribeUpdateTransactionInfo struct { + state protoimpl.MessageState `protogen:"open.v1"` + Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"` + IsVote bool `protobuf:"varint,2,opt,name=is_vote,json=isVote,proto3" json:"is_vote,omitempty"` + Transaction *Transaction `protobuf:"bytes,3,opt,name=transaction,proto3" json:"transaction,omitempty"` + Meta *TransactionStatusMeta `protobuf:"bytes,4,opt,name=meta,proto3" json:"meta,omitempty"` + Index uint64 `protobuf:"varint,5,opt,name=index,proto3" json:"index,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdateTransactionInfo) Reset() { + *x = SubscribeUpdateTransactionInfo{} + mi := &file_geyser_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdateTransactionInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdateTransactionInfo) ProtoMessage() {} + +func (x *SubscribeUpdateTransactionInfo) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[17] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdateTransactionInfo.ProtoReflect.Descriptor instead. +func (*SubscribeUpdateTransactionInfo) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{17} +} + +func (x *SubscribeUpdateTransactionInfo) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +func (x *SubscribeUpdateTransactionInfo) GetIsVote() bool { + if x != nil { + return x.IsVote + } + return false +} + +func (x *SubscribeUpdateTransactionInfo) GetTransaction() *Transaction { + if x != nil { + return x.Transaction + } + return nil +} + +func (x *SubscribeUpdateTransactionInfo) GetMeta() *TransactionStatusMeta { + if x != nil { + return x.Meta + } + return nil +} + +func (x *SubscribeUpdateTransactionInfo) GetIndex() uint64 { + if x != nil { + return x.Index + } + return 0 +} + +type SubscribeUpdateTransactionStatus struct { + state protoimpl.MessageState `protogen:"open.v1"` + Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` + Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"` + IsVote bool `protobuf:"varint,3,opt,name=is_vote,json=isVote,proto3" json:"is_vote,omitempty"` + Index uint64 `protobuf:"varint,4,opt,name=index,proto3" json:"index,omitempty"` + Err *TransactionError `protobuf:"bytes,5,opt,name=err,proto3" json:"err,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdateTransactionStatus) Reset() { + *x = SubscribeUpdateTransactionStatus{} + mi := &file_geyser_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdateTransactionStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdateTransactionStatus) ProtoMessage() {} + +func (x *SubscribeUpdateTransactionStatus) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[18] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdateTransactionStatus.ProtoReflect.Descriptor instead. +func (*SubscribeUpdateTransactionStatus) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{18} +} + +func (x *SubscribeUpdateTransactionStatus) GetSlot() uint64 { + if x != nil { + return x.Slot + } + return 0 +} + +func (x *SubscribeUpdateTransactionStatus) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +func (x *SubscribeUpdateTransactionStatus) GetIsVote() bool { + if x != nil { + return x.IsVote + } + return false +} + +func (x *SubscribeUpdateTransactionStatus) GetIndex() uint64 { + if x != nil { + return x.Index + } + return 0 +} + +func (x *SubscribeUpdateTransactionStatus) GetErr() *TransactionError { + if x != nil { + return x.Err + } + return nil +} + +type SubscribeUpdateBlock struct { + state protoimpl.MessageState `protogen:"open.v1"` + Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` + Blockhash string `protobuf:"bytes,2,opt,name=blockhash,proto3" json:"blockhash,omitempty"` + Rewards *Rewards `protobuf:"bytes,3,opt,name=rewards,proto3" json:"rewards,omitempty"` + BlockTime *UnixTimestamp `protobuf:"bytes,4,opt,name=block_time,json=blockTime,proto3" json:"block_time,omitempty"` + BlockHeight *BlockHeight `protobuf:"bytes,5,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` + ParentSlot uint64 `protobuf:"varint,7,opt,name=parent_slot,json=parentSlot,proto3" json:"parent_slot,omitempty"` + ParentBlockhash string `protobuf:"bytes,8,opt,name=parent_blockhash,json=parentBlockhash,proto3" json:"parent_blockhash,omitempty"` + ExecutedTransactionCount uint64 `protobuf:"varint,9,opt,name=executed_transaction_count,json=executedTransactionCount,proto3" json:"executed_transaction_count,omitempty"` + Transactions []*SubscribeUpdateTransactionInfo `protobuf:"bytes,6,rep,name=transactions,proto3" json:"transactions,omitempty"` + UpdatedAccountCount uint64 `protobuf:"varint,10,opt,name=updated_account_count,json=updatedAccountCount,proto3" json:"updated_account_count,omitempty"` + Accounts []*SubscribeUpdateAccountInfo `protobuf:"bytes,11,rep,name=accounts,proto3" json:"accounts,omitempty"` + EntriesCount uint64 `protobuf:"varint,12,opt,name=entries_count,json=entriesCount,proto3" json:"entries_count,omitempty"` + Entries []*SubscribeUpdateEntry `protobuf:"bytes,13,rep,name=entries,proto3" json:"entries,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdateBlock) Reset() { + *x = SubscribeUpdateBlock{} + mi := &file_geyser_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdateBlock) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdateBlock) ProtoMessage() {} + +func (x *SubscribeUpdateBlock) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[19] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdateBlock.ProtoReflect.Descriptor instead. +func (*SubscribeUpdateBlock) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{19} +} + +func (x *SubscribeUpdateBlock) GetSlot() uint64 { + if x != nil { + return x.Slot + } + return 0 +} + +func (x *SubscribeUpdateBlock) GetBlockhash() string { + if x != nil { + return x.Blockhash + } + return "" +} + +func (x *SubscribeUpdateBlock) GetRewards() *Rewards { + if x != nil { + return x.Rewards + } + return nil +} + +func (x *SubscribeUpdateBlock) GetBlockTime() *UnixTimestamp { + if x != nil { + return x.BlockTime + } + return nil +} + +func (x *SubscribeUpdateBlock) GetBlockHeight() *BlockHeight { + if x != nil { + return x.BlockHeight + } + return nil +} + +func (x *SubscribeUpdateBlock) GetParentSlot() uint64 { + if x != nil { + return x.ParentSlot + } + return 0 +} + +func (x *SubscribeUpdateBlock) GetParentBlockhash() string { + if x != nil { + return x.ParentBlockhash + } + return "" +} + +func (x *SubscribeUpdateBlock) GetExecutedTransactionCount() uint64 { + if x != nil { + return x.ExecutedTransactionCount + } + return 0 +} + +func (x *SubscribeUpdateBlock) GetTransactions() []*SubscribeUpdateTransactionInfo { + if x != nil { + return x.Transactions + } + return nil +} + +func (x *SubscribeUpdateBlock) GetUpdatedAccountCount() uint64 { + if x != nil { + return x.UpdatedAccountCount + } + return 0 +} + +func (x *SubscribeUpdateBlock) GetAccounts() []*SubscribeUpdateAccountInfo { + if x != nil { + return x.Accounts + } + return nil +} + +func (x *SubscribeUpdateBlock) GetEntriesCount() uint64 { + if x != nil { + return x.EntriesCount + } + return 0 +} + +func (x *SubscribeUpdateBlock) GetEntries() []*SubscribeUpdateEntry { + if x != nil { + return x.Entries + } + return nil +} + +type SubscribeUpdateBlockMeta struct { + state protoimpl.MessageState `protogen:"open.v1"` + Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` + Blockhash string `protobuf:"bytes,2,opt,name=blockhash,proto3" json:"blockhash,omitempty"` + Rewards *Rewards `protobuf:"bytes,3,opt,name=rewards,proto3" json:"rewards,omitempty"` + BlockTime *UnixTimestamp `protobuf:"bytes,4,opt,name=block_time,json=blockTime,proto3" json:"block_time,omitempty"` + BlockHeight *BlockHeight `protobuf:"bytes,5,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` + ParentSlot uint64 `protobuf:"varint,6,opt,name=parent_slot,json=parentSlot,proto3" json:"parent_slot,omitempty"` + ParentBlockhash string `protobuf:"bytes,7,opt,name=parent_blockhash,json=parentBlockhash,proto3" json:"parent_blockhash,omitempty"` + ExecutedTransactionCount uint64 `protobuf:"varint,8,opt,name=executed_transaction_count,json=executedTransactionCount,proto3" json:"executed_transaction_count,omitempty"` + EntriesCount uint64 `protobuf:"varint,9,opt,name=entries_count,json=entriesCount,proto3" json:"entries_count,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdateBlockMeta) Reset() { + *x = SubscribeUpdateBlockMeta{} + mi := &file_geyser_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdateBlockMeta) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdateBlockMeta) ProtoMessage() {} + +func (x *SubscribeUpdateBlockMeta) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[20] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdateBlockMeta.ProtoReflect.Descriptor instead. +func (*SubscribeUpdateBlockMeta) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{20} +} + +func (x *SubscribeUpdateBlockMeta) GetSlot() uint64 { + if x != nil { + return x.Slot + } + return 0 +} + +func (x *SubscribeUpdateBlockMeta) GetBlockhash() string { + if x != nil { + return x.Blockhash + } + return "" +} + +func (x *SubscribeUpdateBlockMeta) GetRewards() *Rewards { + if x != nil { + return x.Rewards + } + return nil +} + +func (x *SubscribeUpdateBlockMeta) GetBlockTime() *UnixTimestamp { + if x != nil { + return x.BlockTime + } + return nil +} + +func (x *SubscribeUpdateBlockMeta) GetBlockHeight() *BlockHeight { + if x != nil { + return x.BlockHeight + } + return nil +} + +func (x *SubscribeUpdateBlockMeta) GetParentSlot() uint64 { + if x != nil { + return x.ParentSlot + } + return 0 +} + +func (x *SubscribeUpdateBlockMeta) GetParentBlockhash() string { + if x != nil { + return x.ParentBlockhash + } + return "" +} + +func (x *SubscribeUpdateBlockMeta) GetExecutedTransactionCount() uint64 { + if x != nil { + return x.ExecutedTransactionCount + } + return 0 +} + +func (x *SubscribeUpdateBlockMeta) GetEntriesCount() uint64 { + if x != nil { + return x.EntriesCount + } + return 0 +} + +type SubscribeUpdateEntry struct { + state protoimpl.MessageState `protogen:"open.v1"` + Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` + Index uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` + NumHashes uint64 `protobuf:"varint,3,opt,name=num_hashes,json=numHashes,proto3" json:"num_hashes,omitempty"` + Hash []byte `protobuf:"bytes,4,opt,name=hash,proto3" json:"hash,omitempty"` + ExecutedTransactionCount uint64 `protobuf:"varint,5,opt,name=executed_transaction_count,json=executedTransactionCount,proto3" json:"executed_transaction_count,omitempty"` + StartingTransactionIndex uint64 `protobuf:"varint,6,opt,name=starting_transaction_index,json=startingTransactionIndex,proto3" json:"starting_transaction_index,omitempty"` // added in v1.18, for solana 1.17 value is always 0 + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdateEntry) Reset() { + *x = SubscribeUpdateEntry{} + mi := &file_geyser_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdateEntry) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdateEntry) ProtoMessage() {} + +func (x *SubscribeUpdateEntry) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[21] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdateEntry.ProtoReflect.Descriptor instead. +func (*SubscribeUpdateEntry) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{21} +} + +func (x *SubscribeUpdateEntry) GetSlot() uint64 { + if x != nil { + return x.Slot + } + return 0 +} + +func (x *SubscribeUpdateEntry) GetIndex() uint64 { + if x != nil { + return x.Index + } + return 0 +} + +func (x *SubscribeUpdateEntry) GetNumHashes() uint64 { + if x != nil { + return x.NumHashes + } + return 0 +} + +func (x *SubscribeUpdateEntry) GetHash() []byte { + if x != nil { + return x.Hash + } + return nil +} + +func (x *SubscribeUpdateEntry) GetExecutedTransactionCount() uint64 { + if x != nil { + return x.ExecutedTransactionCount + } + return 0 +} + +func (x *SubscribeUpdateEntry) GetStartingTransactionIndex() uint64 { + if x != nil { + return x.StartingTransactionIndex + } + return 0 +} + +type SubscribeUpdatePing struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdatePing) Reset() { + *x = SubscribeUpdatePing{} + mi := &file_geyser_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdatePing) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdatePing) ProtoMessage() {} + +func (x *SubscribeUpdatePing) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[22] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdatePing.ProtoReflect.Descriptor instead. +func (*SubscribeUpdatePing) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{22} +} + +type SubscribeUpdatePong struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeUpdatePong) Reset() { + *x = SubscribeUpdatePong{} + mi := &file_geyser_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeUpdatePong) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeUpdatePong) ProtoMessage() {} + +func (x *SubscribeUpdatePong) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[23] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeUpdatePong.ProtoReflect.Descriptor instead. +func (*SubscribeUpdatePong) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{23} +} + +func (x *SubscribeUpdatePong) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +type SubscribeReplayInfoRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeReplayInfoRequest) Reset() { + *x = SubscribeReplayInfoRequest{} + mi := &file_geyser_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeReplayInfoRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeReplayInfoRequest) ProtoMessage() {} + +func (x *SubscribeReplayInfoRequest) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[24] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeReplayInfoRequest.ProtoReflect.Descriptor instead. +func (*SubscribeReplayInfoRequest) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{24} +} + +type SubscribeReplayInfoResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + FirstAvailable *uint64 `protobuf:"varint,1,opt,name=first_available,json=firstAvailable,proto3,oneof" json:"first_available,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeReplayInfoResponse) Reset() { + *x = SubscribeReplayInfoResponse{} + mi := &file_geyser_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeReplayInfoResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeReplayInfoResponse) ProtoMessage() {} + +func (x *SubscribeReplayInfoResponse) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[25] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeReplayInfoResponse.ProtoReflect.Descriptor instead. +func (*SubscribeReplayInfoResponse) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{25} +} + +func (x *SubscribeReplayInfoResponse) GetFirstAvailable() uint64 { + if x != nil && x.FirstAvailable != nil { + return *x.FirstAvailable + } + return 0 +} + +type PingRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Count int32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PingRequest) Reset() { + *x = PingRequest{} + mi := &file_geyser_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PingRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PingRequest) ProtoMessage() {} + +func (x *PingRequest) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[26] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PingRequest.ProtoReflect.Descriptor instead. +func (*PingRequest) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{26} +} + +func (x *PingRequest) GetCount() int32 { + if x != nil { + return x.Count + } + return 0 +} + +type PongResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Count int32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PongResponse) Reset() { + *x = PongResponse{} + mi := &file_geyser_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PongResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PongResponse) ProtoMessage() {} + +func (x *PongResponse) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[27] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PongResponse.ProtoReflect.Descriptor instead. +func (*PongResponse) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{27} +} + +func (x *PongResponse) GetCount() int32 { + if x != nil { + return x.Count + } + return 0 +} + +type GetLatestBlockhashRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Commitment *CommitmentLevel `protobuf:"varint,1,opt,name=commitment,proto3,enum=geyser.CommitmentLevel,oneof" json:"commitment,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetLatestBlockhashRequest) Reset() { + *x = GetLatestBlockhashRequest{} + mi := &file_geyser_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetLatestBlockhashRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetLatestBlockhashRequest) ProtoMessage() {} + +func (x *GetLatestBlockhashRequest) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[28] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetLatestBlockhashRequest.ProtoReflect.Descriptor instead. +func (*GetLatestBlockhashRequest) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{28} +} + +func (x *GetLatestBlockhashRequest) GetCommitment() CommitmentLevel { + if x != nil && x.Commitment != nil { + return *x.Commitment + } + return CommitmentLevel_PROCESSED +} + +type GetLatestBlockhashResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` + Blockhash string `protobuf:"bytes,2,opt,name=blockhash,proto3" json:"blockhash,omitempty"` + LastValidBlockHeight uint64 `protobuf:"varint,3,opt,name=last_valid_block_height,json=lastValidBlockHeight,proto3" json:"last_valid_block_height,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetLatestBlockhashResponse) Reset() { + *x = GetLatestBlockhashResponse{} + mi := &file_geyser_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetLatestBlockhashResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetLatestBlockhashResponse) ProtoMessage() {} + +func (x *GetLatestBlockhashResponse) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[29] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetLatestBlockhashResponse.ProtoReflect.Descriptor instead. +func (*GetLatestBlockhashResponse) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{29} +} + +func (x *GetLatestBlockhashResponse) GetSlot() uint64 { + if x != nil { + return x.Slot + } + return 0 +} + +func (x *GetLatestBlockhashResponse) GetBlockhash() string { + if x != nil { + return x.Blockhash + } + return "" +} + +func (x *GetLatestBlockhashResponse) GetLastValidBlockHeight() uint64 { + if x != nil { + return x.LastValidBlockHeight + } + return 0 +} + +type GetBlockHeightRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Commitment *CommitmentLevel `protobuf:"varint,1,opt,name=commitment,proto3,enum=geyser.CommitmentLevel,oneof" json:"commitment,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetBlockHeightRequest) Reset() { + *x = GetBlockHeightRequest{} + mi := &file_geyser_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetBlockHeightRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBlockHeightRequest) ProtoMessage() {} + +func (x *GetBlockHeightRequest) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[30] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBlockHeightRequest.ProtoReflect.Descriptor instead. +func (*GetBlockHeightRequest) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{30} +} + +func (x *GetBlockHeightRequest) GetCommitment() CommitmentLevel { + if x != nil && x.Commitment != nil { + return *x.Commitment + } + return CommitmentLevel_PROCESSED +} + +type GetBlockHeightResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + BlockHeight uint64 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetBlockHeightResponse) Reset() { + *x = GetBlockHeightResponse{} + mi := &file_geyser_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetBlockHeightResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBlockHeightResponse) ProtoMessage() {} + +func (x *GetBlockHeightResponse) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[31] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBlockHeightResponse.ProtoReflect.Descriptor instead. +func (*GetBlockHeightResponse) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{31} +} + +func (x *GetBlockHeightResponse) GetBlockHeight() uint64 { + if x != nil { + return x.BlockHeight + } + return 0 +} + +type GetSlotRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Commitment *CommitmentLevel `protobuf:"varint,1,opt,name=commitment,proto3,enum=geyser.CommitmentLevel,oneof" json:"commitment,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSlotRequest) Reset() { + *x = GetSlotRequest{} + mi := &file_geyser_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSlotRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSlotRequest) ProtoMessage() {} + +func (x *GetSlotRequest) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[32] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSlotRequest.ProtoReflect.Descriptor instead. +func (*GetSlotRequest) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{32} +} + +func (x *GetSlotRequest) GetCommitment() CommitmentLevel { + if x != nil && x.Commitment != nil { + return *x.Commitment + } + return CommitmentLevel_PROCESSED +} + +type GetSlotResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSlotResponse) Reset() { + *x = GetSlotResponse{} + mi := &file_geyser_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSlotResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSlotResponse) ProtoMessage() {} + +func (x *GetSlotResponse) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[33] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSlotResponse.ProtoReflect.Descriptor instead. +func (*GetSlotResponse) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{33} +} + +func (x *GetSlotResponse) GetSlot() uint64 { + if x != nil { + return x.Slot + } + return 0 +} + +type GetVersionRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetVersionRequest) Reset() { + *x = GetVersionRequest{} + mi := &file_geyser_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetVersionRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetVersionRequest) ProtoMessage() {} + +func (x *GetVersionRequest) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[34] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetVersionRequest.ProtoReflect.Descriptor instead. +func (*GetVersionRequest) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{34} +} + +type GetVersionResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetVersionResponse) Reset() { + *x = GetVersionResponse{} + mi := &file_geyser_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetVersionResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetVersionResponse) ProtoMessage() {} + +func (x *GetVersionResponse) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[35] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetVersionResponse.ProtoReflect.Descriptor instead. +func (*GetVersionResponse) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{35} +} + +func (x *GetVersionResponse) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +type IsBlockhashValidRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Blockhash string `protobuf:"bytes,1,opt,name=blockhash,proto3" json:"blockhash,omitempty"` + Commitment *CommitmentLevel `protobuf:"varint,2,opt,name=commitment,proto3,enum=geyser.CommitmentLevel,oneof" json:"commitment,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IsBlockhashValidRequest) Reset() { + *x = IsBlockhashValidRequest{} + mi := &file_geyser_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IsBlockhashValidRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IsBlockhashValidRequest) ProtoMessage() {} + +func (x *IsBlockhashValidRequest) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[36] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IsBlockhashValidRequest.ProtoReflect.Descriptor instead. +func (*IsBlockhashValidRequest) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{36} +} + +func (x *IsBlockhashValidRequest) GetBlockhash() string { + if x != nil { + return x.Blockhash + } + return "" +} + +func (x *IsBlockhashValidRequest) GetCommitment() CommitmentLevel { + if x != nil && x.Commitment != nil { + return *x.Commitment + } + return CommitmentLevel_PROCESSED +} + +type IsBlockhashValidResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` + Valid bool `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IsBlockhashValidResponse) Reset() { + *x = IsBlockhashValidResponse{} + mi := &file_geyser_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IsBlockhashValidResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IsBlockhashValidResponse) ProtoMessage() {} + +func (x *IsBlockhashValidResponse) ProtoReflect() protoreflect.Message { + mi := &file_geyser_proto_msgTypes[37] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IsBlockhashValidResponse.ProtoReflect.Descriptor instead. +func (*IsBlockhashValidResponse) Descriptor() ([]byte, []int) { + return file_geyser_proto_rawDescGZIP(), []int{37} +} + +func (x *IsBlockhashValidResponse) GetSlot() uint64 { + if x != nil { + return x.Slot + } + return 0 +} + +func (x *IsBlockhashValidResponse) GetValid() bool { + if x != nil { + return x.Valid + } + return false +} + +var File_geyser_proto protoreflect.FileDescriptor + +const file_geyser_proto_rawDesc = "" + + "\n" + + "\fgeyser.proto\x12\x06geyser\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x14solana-storage.proto\"\xed\v\n" + + "\x10SubscribeRequest\x12B\n" + + "\baccounts\x18\x01 \x03(\v2&.geyser.SubscribeRequest.AccountsEntryR\baccounts\x129\n" + + "\x05slots\x18\x02 \x03(\v2#.geyser.SubscribeRequest.SlotsEntryR\x05slots\x12N\n" + + "\ftransactions\x18\x03 \x03(\v2*.geyser.SubscribeRequest.TransactionsEntryR\ftransactions\x12a\n" + + "\x13transactions_status\x18\n" + + " \x03(\v20.geyser.SubscribeRequest.TransactionsStatusEntryR\x12transactionsStatus\x12<\n" + + "\x06blocks\x18\x04 \x03(\v2$.geyser.SubscribeRequest.BlocksEntryR\x06blocks\x12I\n" + + "\vblocks_meta\x18\x05 \x03(\v2(.geyser.SubscribeRequest.BlocksMetaEntryR\n" + + "blocksMeta\x129\n" + + "\x05entry\x18\b \x03(\v2#.geyser.SubscribeRequest.EntryEntryR\x05entry\x12<\n" + + "\n" + + "commitment\x18\x06 \x01(\x0e2\x17.geyser.CommitmentLevelH\x00R\n" + + "commitment\x88\x01\x01\x12Y\n" + + "\x13accounts_data_slice\x18\a \x03(\v2).geyser.SubscribeRequestAccountsDataSliceR\x11accountsDataSlice\x125\n" + + "\x04ping\x18\t \x01(\v2\x1c.geyser.SubscribeRequestPingH\x01R\x04ping\x88\x01\x01\x12 \n" + + "\tfrom_slot\x18\v \x01(\x04H\x02R\bfromSlot\x88\x01\x01\x1ac\n" + + "\rAccountsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12<\n" + + "\x05value\x18\x02 \x01(\v2&.geyser.SubscribeRequestFilterAccountsR\x05value:\x028\x01\x1a]\n" + + "\n" + + "SlotsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x129\n" + + "\x05value\x18\x02 \x01(\v2#.geyser.SubscribeRequestFilterSlotsR\x05value:\x028\x01\x1ak\n" + + "\x11TransactionsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12@\n" + + "\x05value\x18\x02 \x01(\v2*.geyser.SubscribeRequestFilterTransactionsR\x05value:\x028\x01\x1aq\n" + + "\x17TransactionsStatusEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12@\n" + + "\x05value\x18\x02 \x01(\v2*.geyser.SubscribeRequestFilterTransactionsR\x05value:\x028\x01\x1a_\n" + + "\vBlocksEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12:\n" + + "\x05value\x18\x02 \x01(\v2$.geyser.SubscribeRequestFilterBlocksR\x05value:\x028\x01\x1ag\n" + + "\x0fBlocksMetaEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12>\n" + + "\x05value\x18\x02 \x01(\v2(.geyser.SubscribeRequestFilterBlocksMetaR\x05value:\x028\x01\x1a]\n" + + "\n" + + "EntryEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x129\n" + + "\x05value\x18\x02 \x01(\v2#.geyser.SubscribeRequestFilterEntryR\x05value:\x028\x01B\r\n" + + "\v_commitmentB\a\n" + + "\x05_pingB\f\n" + + "\n" + + "_from_slot\"\xee\x01\n" + + "\x1eSubscribeRequestFilterAccounts\x12\x18\n" + + "\aaccount\x18\x02 \x03(\tR\aaccount\x12\x14\n" + + "\x05owner\x18\x03 \x03(\tR\x05owner\x12F\n" + + "\afilters\x18\x04 \x03(\v2,.geyser.SubscribeRequestFilterAccountsFilterR\afilters\x129\n" + + "\x16nonempty_txn_signature\x18\x05 \x01(\bH\x00R\x14nonemptyTxnSignature\x88\x01\x01B\x19\n" + + "\x17_nonempty_txn_signature\"\xa2\x02\n" + + "$SubscribeRequestFilterAccountsFilter\x12L\n" + + "\x06memcmp\x18\x01 \x01(\v22.geyser.SubscribeRequestFilterAccountsFilterMemcmpH\x00R\x06memcmp\x12\x1c\n" + + "\bdatasize\x18\x02 \x01(\x04H\x00R\bdatasize\x120\n" + + "\x13token_account_state\x18\x03 \x01(\bH\x00R\x11tokenAccountState\x12R\n" + + "\blamports\x18\x04 \x01(\v24.geyser.SubscribeRequestFilterAccountsFilterLamportsH\x00R\blamportsB\b\n" + + "\x06filter\"\x98\x01\n" + + "*SubscribeRequestFilterAccountsFilterMemcmp\x12\x16\n" + + "\x06offset\x18\x01 \x01(\x04R\x06offset\x12\x16\n" + + "\x05bytes\x18\x02 \x01(\fH\x00R\x05bytes\x12\x18\n" + + "\x06base58\x18\x03 \x01(\tH\x00R\x06base58\x12\x18\n" + + "\x06base64\x18\x04 \x01(\tH\x00R\x06base64B\x06\n" + + "\x04data\"}\n" + + ",SubscribeRequestFilterAccountsFilterLamports\x12\x10\n" + + "\x02eq\x18\x01 \x01(\x04H\x00R\x02eq\x12\x10\n" + + "\x02ne\x18\x02 \x01(\x04H\x00R\x02ne\x12\x10\n" + + "\x02lt\x18\x03 \x01(\x04H\x00R\x02lt\x12\x10\n" + + "\x02gt\x18\x04 \x01(\x04H\x00R\x02gtB\x05\n" + + "\x03cmp\"\xb5\x01\n" + + "\x1bSubscribeRequestFilterSlots\x125\n" + + "\x14filter_by_commitment\x18\x01 \x01(\bH\x00R\x12filterByCommitment\x88\x01\x01\x120\n" + + "\x11interslot_updates\x18\x02 \x01(\bH\x01R\x10interslotUpdates\x88\x01\x01B\x17\n" + + "\x15_filter_by_commitmentB\x14\n" + + "\x12_interslot_updates\"\x9c\x02\n" + + "\"SubscribeRequestFilterTransactions\x12\x17\n" + + "\x04vote\x18\x01 \x01(\bH\x00R\x04vote\x88\x01\x01\x12\x1b\n" + + "\x06failed\x18\x02 \x01(\bH\x01R\x06failed\x88\x01\x01\x12!\n" + + "\tsignature\x18\x05 \x01(\tH\x02R\tsignature\x88\x01\x01\x12'\n" + + "\x0faccount_include\x18\x03 \x03(\tR\x0eaccountInclude\x12'\n" + + "\x0faccount_exclude\x18\x04 \x03(\tR\x0eaccountExclude\x12)\n" + + "\x10account_required\x18\x06 \x03(\tR\x0faccountRequiredB\a\n" + + "\x05_voteB\t\n" + + "\a_failedB\f\n" + + "\n" + + "_signature\"\x9f\x02\n" + + "\x1cSubscribeRequestFilterBlocks\x12'\n" + + "\x0faccount_include\x18\x01 \x03(\tR\x0eaccountInclude\x126\n" + + "\x14include_transactions\x18\x02 \x01(\bH\x00R\x13includeTransactions\x88\x01\x01\x12.\n" + + "\x10include_accounts\x18\x03 \x01(\bH\x01R\x0fincludeAccounts\x88\x01\x01\x12,\n" + + "\x0finclude_entries\x18\x04 \x01(\bH\x02R\x0eincludeEntries\x88\x01\x01B\x17\n" + + "\x15_include_transactionsB\x13\n" + + "\x11_include_accountsB\x12\n" + + "\x10_include_entries\"\"\n" + + " SubscribeRequestFilterBlocksMeta\"\x1d\n" + + "\x1bSubscribeRequestFilterEntry\"S\n" + + "!SubscribeRequestAccountsDataSlice\x12\x16\n" + + "\x06offset\x18\x01 \x01(\x04R\x06offset\x12\x16\n" + + "\x06length\x18\x02 \x01(\x04R\x06length\"&\n" + + "\x14SubscribeRequestPing\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x05R\x02id\"\x9d\x05\n" + + "\x0fSubscribeUpdate\x12\x18\n" + + "\afilters\x18\x01 \x03(\tR\afilters\x12:\n" + + "\aaccount\x18\x02 \x01(\v2\x1e.geyser.SubscribeUpdateAccountH\x00R\aaccount\x121\n" + + "\x04slot\x18\x03 \x01(\v2\x1b.geyser.SubscribeUpdateSlotH\x00R\x04slot\x12F\n" + + "\vtransaction\x18\x04 \x01(\v2\".geyser.SubscribeUpdateTransactionH\x00R\vtransaction\x12Y\n" + + "\x12transaction_status\x18\n" + + " \x01(\v2(.geyser.SubscribeUpdateTransactionStatusH\x00R\x11transactionStatus\x124\n" + + "\x05block\x18\x05 \x01(\v2\x1c.geyser.SubscribeUpdateBlockH\x00R\x05block\x121\n" + + "\x04ping\x18\x06 \x01(\v2\x1b.geyser.SubscribeUpdatePingH\x00R\x04ping\x121\n" + + "\x04pong\x18\t \x01(\v2\x1b.geyser.SubscribeUpdatePongH\x00R\x04pong\x12A\n" + + "\n" + + "block_meta\x18\a \x01(\v2 .geyser.SubscribeUpdateBlockMetaH\x00R\tblockMeta\x124\n" + + "\x05entry\x18\b \x01(\v2\x1c.geyser.SubscribeUpdateEntryH\x00R\x05entry\x129\n" + + "\n" + + "created_at\x18\v \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAtB\x0e\n" + + "\fupdate_oneof\"\x89\x01\n" + + "\x16SubscribeUpdateAccount\x12<\n" + + "\aaccount\x18\x01 \x01(\v2\".geyser.SubscribeUpdateAccountInfoR\aaccount\x12\x12\n" + + "\x04slot\x18\x02 \x01(\x04R\x04slot\x12\x1d\n" + + "\n" + + "is_startup\x18\x03 \x01(\bR\tisStartup\"\x9a\x02\n" + + "\x1aSubscribeUpdateAccountInfo\x12\x16\n" + + "\x06pubkey\x18\x01 \x01(\fR\x06pubkey\x12\x1a\n" + + "\blamports\x18\x02 \x01(\x04R\blamports\x12\x14\n" + + "\x05owner\x18\x03 \x01(\fR\x05owner\x12\x1e\n" + + "\n" + + "executable\x18\x04 \x01(\bR\n" + + "executable\x12\x1d\n" + + "\n" + + "rent_epoch\x18\x05 \x01(\x04R\trentEpoch\x12\x12\n" + + "\x04data\x18\x06 \x01(\fR\x04data\x12#\n" + + "\rwrite_version\x18\a \x01(\x04R\fwriteVersion\x12(\n" + + "\rtxn_signature\x18\b \x01(\fH\x00R\ftxnSignature\x88\x01\x01B\x10\n" + + "\x0e_txn_signature\"\xb0\x01\n" + + "\x13SubscribeUpdateSlot\x12\x12\n" + + "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x1b\n" + + "\x06parent\x18\x02 \x01(\x04H\x00R\x06parent\x88\x01\x01\x12*\n" + + "\x06status\x18\x03 \x01(\x0e2\x12.geyser.SlotStatusR\x06status\x12\"\n" + + "\n" + + "dead_error\x18\x04 \x01(\tH\x01R\tdeadError\x88\x01\x01B\t\n" + + "\a_parentB\r\n" + + "\v_dead_error\"z\n" + + "\x1aSubscribeUpdateTransaction\x12H\n" + + "\vtransaction\x18\x01 \x01(\v2&.geyser.SubscribeUpdateTransactionInfoR\vtransaction\x12\x12\n" + + "\x04slot\x18\x02 \x01(\x04R\x04slot\"\x85\x02\n" + + "\x1eSubscribeUpdateTransactionInfo\x12\x1c\n" + + "\tsignature\x18\x01 \x01(\fR\tsignature\x12\x17\n" + + "\ais_vote\x18\x02 \x01(\bR\x06isVote\x12L\n" + + "\vtransaction\x18\x03 \x01(\v2*.solana.storage.ConfirmedBlock.TransactionR\vtransaction\x12H\n" + + "\x04meta\x18\x04 \x01(\v24.solana.storage.ConfirmedBlock.TransactionStatusMetaR\x04meta\x12\x14\n" + + "\x05index\x18\x05 \x01(\x04R\x05index\"\xc6\x01\n" + + " SubscribeUpdateTransactionStatus\x12\x12\n" + + "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x1c\n" + + "\tsignature\x18\x02 \x01(\fR\tsignature\x12\x17\n" + + "\ais_vote\x18\x03 \x01(\bR\x06isVote\x12\x14\n" + + "\x05index\x18\x04 \x01(\x04R\x05index\x12A\n" + + "\x03err\x18\x05 \x01(\v2/.solana.storage.ConfirmedBlock.TransactionErrorR\x03err\"\xcd\x05\n" + + "\x14SubscribeUpdateBlock\x12\x12\n" + + "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x1c\n" + + "\tblockhash\x18\x02 \x01(\tR\tblockhash\x12@\n" + + "\arewards\x18\x03 \x01(\v2&.solana.storage.ConfirmedBlock.RewardsR\arewards\x12K\n" + + "\n" + + "block_time\x18\x04 \x01(\v2,.solana.storage.ConfirmedBlock.UnixTimestampR\tblockTime\x12M\n" + + "\fblock_height\x18\x05 \x01(\v2*.solana.storage.ConfirmedBlock.BlockHeightR\vblockHeight\x12\x1f\n" + + "\vparent_slot\x18\a \x01(\x04R\n" + + "parentSlot\x12)\n" + + "\x10parent_blockhash\x18\b \x01(\tR\x0fparentBlockhash\x12<\n" + + "\x1aexecuted_transaction_count\x18\t \x01(\x04R\x18executedTransactionCount\x12J\n" + + "\ftransactions\x18\x06 \x03(\v2&.geyser.SubscribeUpdateTransactionInfoR\ftransactions\x122\n" + + "\x15updated_account_count\x18\n" + + " \x01(\x04R\x13updatedAccountCount\x12>\n" + + "\baccounts\x18\v \x03(\v2\".geyser.SubscribeUpdateAccountInfoR\baccounts\x12#\n" + + "\rentries_count\x18\f \x01(\x04R\fentriesCount\x126\n" + + "\aentries\x18\r \x03(\v2\x1c.geyser.SubscribeUpdateEntryR\aentries\"\xd9\x03\n" + + "\x18SubscribeUpdateBlockMeta\x12\x12\n" + + "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x1c\n" + + "\tblockhash\x18\x02 \x01(\tR\tblockhash\x12@\n" + + "\arewards\x18\x03 \x01(\v2&.solana.storage.ConfirmedBlock.RewardsR\arewards\x12K\n" + + "\n" + + "block_time\x18\x04 \x01(\v2,.solana.storage.ConfirmedBlock.UnixTimestampR\tblockTime\x12M\n" + + "\fblock_height\x18\x05 \x01(\v2*.solana.storage.ConfirmedBlock.BlockHeightR\vblockHeight\x12\x1f\n" + + "\vparent_slot\x18\x06 \x01(\x04R\n" + + "parentSlot\x12)\n" + + "\x10parent_blockhash\x18\a \x01(\tR\x0fparentBlockhash\x12<\n" + + "\x1aexecuted_transaction_count\x18\b \x01(\x04R\x18executedTransactionCount\x12#\n" + + "\rentries_count\x18\t \x01(\x04R\fentriesCount\"\xef\x01\n" + + "\x14SubscribeUpdateEntry\x12\x12\n" + + "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x14\n" + + "\x05index\x18\x02 \x01(\x04R\x05index\x12\x1d\n" + + "\n" + + "num_hashes\x18\x03 \x01(\x04R\tnumHashes\x12\x12\n" + + "\x04hash\x18\x04 \x01(\fR\x04hash\x12<\n" + + "\x1aexecuted_transaction_count\x18\x05 \x01(\x04R\x18executedTransactionCount\x12<\n" + + "\x1astarting_transaction_index\x18\x06 \x01(\x04R\x18startingTransactionIndex\"\x15\n" + + "\x13SubscribeUpdatePing\"%\n" + + "\x13SubscribeUpdatePong\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x05R\x02id\"\x1c\n" + + "\x1aSubscribeReplayInfoRequest\"_\n" + + "\x1bSubscribeReplayInfoResponse\x12,\n" + + "\x0ffirst_available\x18\x01 \x01(\x04H\x00R\x0efirstAvailable\x88\x01\x01B\x12\n" + + "\x10_first_available\"#\n" + + "\vPingRequest\x12\x14\n" + + "\x05count\x18\x01 \x01(\x05R\x05count\"$\n" + + "\fPongResponse\x12\x14\n" + + "\x05count\x18\x01 \x01(\x05R\x05count\"h\n" + + "\x19GetLatestBlockhashRequest\x12<\n" + + "\n" + + "commitment\x18\x01 \x01(\x0e2\x17.geyser.CommitmentLevelH\x00R\n" + + "commitment\x88\x01\x01B\r\n" + + "\v_commitment\"\x85\x01\n" + + "\x1aGetLatestBlockhashResponse\x12\x12\n" + + "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x1c\n" + + "\tblockhash\x18\x02 \x01(\tR\tblockhash\x125\n" + + "\x17last_valid_block_height\x18\x03 \x01(\x04R\x14lastValidBlockHeight\"d\n" + + "\x15GetBlockHeightRequest\x12<\n" + + "\n" + + "commitment\x18\x01 \x01(\x0e2\x17.geyser.CommitmentLevelH\x00R\n" + + "commitment\x88\x01\x01B\r\n" + + "\v_commitment\";\n" + + "\x16GetBlockHeightResponse\x12!\n" + + "\fblock_height\x18\x01 \x01(\x04R\vblockHeight\"]\n" + + "\x0eGetSlotRequest\x12<\n" + + "\n" + + "commitment\x18\x01 \x01(\x0e2\x17.geyser.CommitmentLevelH\x00R\n" + + "commitment\x88\x01\x01B\r\n" + + "\v_commitment\"%\n" + + "\x0fGetSlotResponse\x12\x12\n" + + "\x04slot\x18\x01 \x01(\x04R\x04slot\"\x13\n" + + "\x11GetVersionRequest\".\n" + + "\x12GetVersionResponse\x12\x18\n" + + "\aversion\x18\x01 \x01(\tR\aversion\"\x84\x01\n" + + "\x17IsBlockhashValidRequest\x12\x1c\n" + + "\tblockhash\x18\x01 \x01(\tR\tblockhash\x12<\n" + + "\n" + + "commitment\x18\x02 \x01(\x0e2\x17.geyser.CommitmentLevelH\x00R\n" + + "commitment\x88\x01\x01B\r\n" + + "\v_commitment\"D\n" + + "\x18IsBlockhashValidResponse\x12\x12\n" + + "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x14\n" + + "\x05valid\x18\x02 \x01(\bR\x05valid*>\n" + + "\x0fCommitmentLevel\x12\r\n" + + "\tPROCESSED\x10\x00\x12\r\n" + + "\tCONFIRMED\x10\x01\x12\r\n" + + "\tFINALIZED\x10\x02*\xa1\x01\n" + + "\n" + + "SlotStatus\x12\x12\n" + + "\x0eSLOT_PROCESSED\x10\x00\x12\x12\n" + + "\x0eSLOT_CONFIRMED\x10\x01\x12\x12\n" + + "\x0eSLOT_FINALIZED\x10\x02\x12\x1d\n" + + "\x19SLOT_FIRST_SHRED_RECEIVED\x10\x03\x12\x12\n" + + "\x0eSLOT_COMPLETED\x10\x04\x12\x15\n" + + "\x11SLOT_CREATED_BANK\x10\x05\x12\r\n" + + "\tSLOT_DEAD\x10\x062\xf5\x04\n" + + "\x06Geyser\x12D\n" + + "\tSubscribe\x12\x18.geyser.SubscribeRequest\x1a\x17.geyser.SubscribeUpdate\"\x00(\x010\x01\x12`\n" + + "\x13SubscribeReplayInfo\x12\".geyser.SubscribeReplayInfoRequest\x1a#.geyser.SubscribeReplayInfoResponse\"\x00\x123\n" + + "\x04Ping\x12\x13.geyser.PingRequest\x1a\x14.geyser.PongResponse\"\x00\x12]\n" + + "\x12GetLatestBlockhash\x12!.geyser.GetLatestBlockhashRequest\x1a\".geyser.GetLatestBlockhashResponse\"\x00\x12Q\n" + + "\x0eGetBlockHeight\x12\x1d.geyser.GetBlockHeightRequest\x1a\x1e.geyser.GetBlockHeightResponse\"\x00\x12<\n" + + "\aGetSlot\x12\x16.geyser.GetSlotRequest\x1a\x17.geyser.GetSlotResponse\"\x00\x12W\n" + + "\x10IsBlockhashValid\x12\x1f.geyser.IsBlockhashValidRequest\x1a .geyser.IsBlockhashValidResponse\"\x00\x12E\n" + + "\n" + + "GetVersion\x12\x19.geyser.GetVersionRequest\x1a\x1a.geyser.GetVersionResponse\"\x00B4Z2github.com/Overclock-Validator/mithril/pkg/grpc/pbP\x01b\x06proto3" + +var ( + file_geyser_proto_rawDescOnce sync.Once + file_geyser_proto_rawDescData []byte +) + +func file_geyser_proto_rawDescGZIP() []byte { + file_geyser_proto_rawDescOnce.Do(func() { + file_geyser_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_geyser_proto_rawDesc), len(file_geyser_proto_rawDesc))) + }) + return file_geyser_proto_rawDescData +} + +var file_geyser_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_geyser_proto_msgTypes = make([]protoimpl.MessageInfo, 45) +var file_geyser_proto_goTypes = []any{ + (CommitmentLevel)(0), // 0: geyser.CommitmentLevel + (SlotStatus)(0), // 1: geyser.SlotStatus + (*SubscribeRequest)(nil), // 2: geyser.SubscribeRequest + (*SubscribeRequestFilterAccounts)(nil), // 3: geyser.SubscribeRequestFilterAccounts + (*SubscribeRequestFilterAccountsFilter)(nil), // 4: geyser.SubscribeRequestFilterAccountsFilter + (*SubscribeRequestFilterAccountsFilterMemcmp)(nil), // 5: geyser.SubscribeRequestFilterAccountsFilterMemcmp + (*SubscribeRequestFilterAccountsFilterLamports)(nil), // 6: geyser.SubscribeRequestFilterAccountsFilterLamports + (*SubscribeRequestFilterSlots)(nil), // 7: geyser.SubscribeRequestFilterSlots + (*SubscribeRequestFilterTransactions)(nil), // 8: geyser.SubscribeRequestFilterTransactions + (*SubscribeRequestFilterBlocks)(nil), // 9: geyser.SubscribeRequestFilterBlocks + (*SubscribeRequestFilterBlocksMeta)(nil), // 10: geyser.SubscribeRequestFilterBlocksMeta + (*SubscribeRequestFilterEntry)(nil), // 11: geyser.SubscribeRequestFilterEntry + (*SubscribeRequestAccountsDataSlice)(nil), // 12: geyser.SubscribeRequestAccountsDataSlice + (*SubscribeRequestPing)(nil), // 13: geyser.SubscribeRequestPing + (*SubscribeUpdate)(nil), // 14: geyser.SubscribeUpdate + (*SubscribeUpdateAccount)(nil), // 15: geyser.SubscribeUpdateAccount + (*SubscribeUpdateAccountInfo)(nil), // 16: geyser.SubscribeUpdateAccountInfo + (*SubscribeUpdateSlot)(nil), // 17: geyser.SubscribeUpdateSlot + (*SubscribeUpdateTransaction)(nil), // 18: geyser.SubscribeUpdateTransaction + (*SubscribeUpdateTransactionInfo)(nil), // 19: geyser.SubscribeUpdateTransactionInfo + (*SubscribeUpdateTransactionStatus)(nil), // 20: geyser.SubscribeUpdateTransactionStatus + (*SubscribeUpdateBlock)(nil), // 21: geyser.SubscribeUpdateBlock + (*SubscribeUpdateBlockMeta)(nil), // 22: geyser.SubscribeUpdateBlockMeta + (*SubscribeUpdateEntry)(nil), // 23: geyser.SubscribeUpdateEntry + (*SubscribeUpdatePing)(nil), // 24: geyser.SubscribeUpdatePing + (*SubscribeUpdatePong)(nil), // 25: geyser.SubscribeUpdatePong + (*SubscribeReplayInfoRequest)(nil), // 26: geyser.SubscribeReplayInfoRequest + (*SubscribeReplayInfoResponse)(nil), // 27: geyser.SubscribeReplayInfoResponse + (*PingRequest)(nil), // 28: geyser.PingRequest + (*PongResponse)(nil), // 29: geyser.PongResponse + (*GetLatestBlockhashRequest)(nil), // 30: geyser.GetLatestBlockhashRequest + (*GetLatestBlockhashResponse)(nil), // 31: geyser.GetLatestBlockhashResponse + (*GetBlockHeightRequest)(nil), // 32: geyser.GetBlockHeightRequest + (*GetBlockHeightResponse)(nil), // 33: geyser.GetBlockHeightResponse + (*GetSlotRequest)(nil), // 34: geyser.GetSlotRequest + (*GetSlotResponse)(nil), // 35: geyser.GetSlotResponse + (*GetVersionRequest)(nil), // 36: geyser.GetVersionRequest + (*GetVersionResponse)(nil), // 37: geyser.GetVersionResponse + (*IsBlockhashValidRequest)(nil), // 38: geyser.IsBlockhashValidRequest + (*IsBlockhashValidResponse)(nil), // 39: geyser.IsBlockhashValidResponse + nil, // 40: geyser.SubscribeRequest.AccountsEntry + nil, // 41: geyser.SubscribeRequest.SlotsEntry + nil, // 42: geyser.SubscribeRequest.TransactionsEntry + nil, // 43: geyser.SubscribeRequest.TransactionsStatusEntry + nil, // 44: geyser.SubscribeRequest.BlocksEntry + nil, // 45: geyser.SubscribeRequest.BlocksMetaEntry + nil, // 46: geyser.SubscribeRequest.EntryEntry + (*timestamppb.Timestamp)(nil), // 47: google.protobuf.Timestamp + (*Transaction)(nil), // 48: solana.storage.ConfirmedBlock.Transaction + (*TransactionStatusMeta)(nil), // 49: solana.storage.ConfirmedBlock.TransactionStatusMeta + (*TransactionError)(nil), // 50: solana.storage.ConfirmedBlock.TransactionError + (*Rewards)(nil), // 51: solana.storage.ConfirmedBlock.Rewards + (*UnixTimestamp)(nil), // 52: solana.storage.ConfirmedBlock.UnixTimestamp + (*BlockHeight)(nil), // 53: solana.storage.ConfirmedBlock.BlockHeight +} +var file_geyser_proto_depIdxs = []int32{ + 40, // 0: geyser.SubscribeRequest.accounts:type_name -> geyser.SubscribeRequest.AccountsEntry + 41, // 1: geyser.SubscribeRequest.slots:type_name -> geyser.SubscribeRequest.SlotsEntry + 42, // 2: geyser.SubscribeRequest.transactions:type_name -> geyser.SubscribeRequest.TransactionsEntry + 43, // 3: geyser.SubscribeRequest.transactions_status:type_name -> geyser.SubscribeRequest.TransactionsStatusEntry + 44, // 4: geyser.SubscribeRequest.blocks:type_name -> geyser.SubscribeRequest.BlocksEntry + 45, // 5: geyser.SubscribeRequest.blocks_meta:type_name -> geyser.SubscribeRequest.BlocksMetaEntry + 46, // 6: geyser.SubscribeRequest.entry:type_name -> geyser.SubscribeRequest.EntryEntry + 0, // 7: geyser.SubscribeRequest.commitment:type_name -> geyser.CommitmentLevel + 12, // 8: geyser.SubscribeRequest.accounts_data_slice:type_name -> geyser.SubscribeRequestAccountsDataSlice + 13, // 9: geyser.SubscribeRequest.ping:type_name -> geyser.SubscribeRequestPing + 4, // 10: geyser.SubscribeRequestFilterAccounts.filters:type_name -> geyser.SubscribeRequestFilterAccountsFilter + 5, // 11: geyser.SubscribeRequestFilterAccountsFilter.memcmp:type_name -> geyser.SubscribeRequestFilterAccountsFilterMemcmp + 6, // 12: geyser.SubscribeRequestFilterAccountsFilter.lamports:type_name -> geyser.SubscribeRequestFilterAccountsFilterLamports + 15, // 13: geyser.SubscribeUpdate.account:type_name -> geyser.SubscribeUpdateAccount + 17, // 14: geyser.SubscribeUpdate.slot:type_name -> geyser.SubscribeUpdateSlot + 18, // 15: geyser.SubscribeUpdate.transaction:type_name -> geyser.SubscribeUpdateTransaction + 20, // 16: geyser.SubscribeUpdate.transaction_status:type_name -> geyser.SubscribeUpdateTransactionStatus + 21, // 17: geyser.SubscribeUpdate.block:type_name -> geyser.SubscribeUpdateBlock + 24, // 18: geyser.SubscribeUpdate.ping:type_name -> geyser.SubscribeUpdatePing + 25, // 19: geyser.SubscribeUpdate.pong:type_name -> geyser.SubscribeUpdatePong + 22, // 20: geyser.SubscribeUpdate.block_meta:type_name -> geyser.SubscribeUpdateBlockMeta + 23, // 21: geyser.SubscribeUpdate.entry:type_name -> geyser.SubscribeUpdateEntry + 47, // 22: geyser.SubscribeUpdate.created_at:type_name -> google.protobuf.Timestamp + 16, // 23: geyser.SubscribeUpdateAccount.account:type_name -> geyser.SubscribeUpdateAccountInfo + 1, // 24: geyser.SubscribeUpdateSlot.status:type_name -> geyser.SlotStatus + 19, // 25: geyser.SubscribeUpdateTransaction.transaction:type_name -> geyser.SubscribeUpdateTransactionInfo + 48, // 26: geyser.SubscribeUpdateTransactionInfo.transaction:type_name -> solana.storage.ConfirmedBlock.Transaction + 49, // 27: geyser.SubscribeUpdateTransactionInfo.meta:type_name -> solana.storage.ConfirmedBlock.TransactionStatusMeta + 50, // 28: geyser.SubscribeUpdateTransactionStatus.err:type_name -> solana.storage.ConfirmedBlock.TransactionError + 51, // 29: geyser.SubscribeUpdateBlock.rewards:type_name -> solana.storage.ConfirmedBlock.Rewards + 52, // 30: geyser.SubscribeUpdateBlock.block_time:type_name -> solana.storage.ConfirmedBlock.UnixTimestamp + 53, // 31: geyser.SubscribeUpdateBlock.block_height:type_name -> solana.storage.ConfirmedBlock.BlockHeight + 19, // 32: geyser.SubscribeUpdateBlock.transactions:type_name -> geyser.SubscribeUpdateTransactionInfo + 16, // 33: geyser.SubscribeUpdateBlock.accounts:type_name -> geyser.SubscribeUpdateAccountInfo + 23, // 34: geyser.SubscribeUpdateBlock.entries:type_name -> geyser.SubscribeUpdateEntry + 51, // 35: geyser.SubscribeUpdateBlockMeta.rewards:type_name -> solana.storage.ConfirmedBlock.Rewards + 52, // 36: geyser.SubscribeUpdateBlockMeta.block_time:type_name -> solana.storage.ConfirmedBlock.UnixTimestamp + 53, // 37: geyser.SubscribeUpdateBlockMeta.block_height:type_name -> solana.storage.ConfirmedBlock.BlockHeight + 0, // 38: geyser.GetLatestBlockhashRequest.commitment:type_name -> geyser.CommitmentLevel + 0, // 39: geyser.GetBlockHeightRequest.commitment:type_name -> geyser.CommitmentLevel + 0, // 40: geyser.GetSlotRequest.commitment:type_name -> geyser.CommitmentLevel + 0, // 41: geyser.IsBlockhashValidRequest.commitment:type_name -> geyser.CommitmentLevel + 3, // 42: geyser.SubscribeRequest.AccountsEntry.value:type_name -> geyser.SubscribeRequestFilterAccounts + 7, // 43: geyser.SubscribeRequest.SlotsEntry.value:type_name -> geyser.SubscribeRequestFilterSlots + 8, // 44: geyser.SubscribeRequest.TransactionsEntry.value:type_name -> geyser.SubscribeRequestFilterTransactions + 8, // 45: geyser.SubscribeRequest.TransactionsStatusEntry.value:type_name -> geyser.SubscribeRequestFilterTransactions + 9, // 46: geyser.SubscribeRequest.BlocksEntry.value:type_name -> geyser.SubscribeRequestFilterBlocks + 10, // 47: geyser.SubscribeRequest.BlocksMetaEntry.value:type_name -> geyser.SubscribeRequestFilterBlocksMeta + 11, // 48: geyser.SubscribeRequest.EntryEntry.value:type_name -> geyser.SubscribeRequestFilterEntry + 2, // 49: geyser.Geyser.Subscribe:input_type -> geyser.SubscribeRequest + 26, // 50: geyser.Geyser.SubscribeReplayInfo:input_type -> geyser.SubscribeReplayInfoRequest + 28, // 51: geyser.Geyser.Ping:input_type -> geyser.PingRequest + 30, // 52: geyser.Geyser.GetLatestBlockhash:input_type -> geyser.GetLatestBlockhashRequest + 32, // 53: geyser.Geyser.GetBlockHeight:input_type -> geyser.GetBlockHeightRequest + 34, // 54: geyser.Geyser.GetSlot:input_type -> geyser.GetSlotRequest + 38, // 55: geyser.Geyser.IsBlockhashValid:input_type -> geyser.IsBlockhashValidRequest + 36, // 56: geyser.Geyser.GetVersion:input_type -> geyser.GetVersionRequest + 14, // 57: geyser.Geyser.Subscribe:output_type -> geyser.SubscribeUpdate + 27, // 58: geyser.Geyser.SubscribeReplayInfo:output_type -> geyser.SubscribeReplayInfoResponse + 29, // 59: geyser.Geyser.Ping:output_type -> geyser.PongResponse + 31, // 60: geyser.Geyser.GetLatestBlockhash:output_type -> geyser.GetLatestBlockhashResponse + 33, // 61: geyser.Geyser.GetBlockHeight:output_type -> geyser.GetBlockHeightResponse + 35, // 62: geyser.Geyser.GetSlot:output_type -> geyser.GetSlotResponse + 39, // 63: geyser.Geyser.IsBlockhashValid:output_type -> geyser.IsBlockhashValidResponse + 37, // 64: geyser.Geyser.GetVersion:output_type -> geyser.GetVersionResponse + 57, // [57:65] is the sub-list for method output_type + 49, // [49:57] is the sub-list for method input_type + 49, // [49:49] is the sub-list for extension type_name + 49, // [49:49] is the sub-list for extension extendee + 0, // [0:49] is the sub-list for field type_name +} + +func init() { file_geyser_proto_init() } +func file_geyser_proto_init() { + if File_geyser_proto != nil { + return + } + file_solana_storage_proto_init() + file_geyser_proto_msgTypes[0].OneofWrappers = []any{} + file_geyser_proto_msgTypes[1].OneofWrappers = []any{} + file_geyser_proto_msgTypes[2].OneofWrappers = []any{ + (*SubscribeRequestFilterAccountsFilter_Memcmp)(nil), + (*SubscribeRequestFilterAccountsFilter_Datasize)(nil), + (*SubscribeRequestFilterAccountsFilter_TokenAccountState)(nil), + (*SubscribeRequestFilterAccountsFilter_Lamports)(nil), + } + file_geyser_proto_msgTypes[3].OneofWrappers = []any{ + (*SubscribeRequestFilterAccountsFilterMemcmp_Bytes)(nil), + (*SubscribeRequestFilterAccountsFilterMemcmp_Base58)(nil), + (*SubscribeRequestFilterAccountsFilterMemcmp_Base64)(nil), + } + file_geyser_proto_msgTypes[4].OneofWrappers = []any{ + (*SubscribeRequestFilterAccountsFilterLamports_Eq)(nil), + (*SubscribeRequestFilterAccountsFilterLamports_Ne)(nil), + (*SubscribeRequestFilterAccountsFilterLamports_Lt)(nil), + (*SubscribeRequestFilterAccountsFilterLamports_Gt)(nil), + } + file_geyser_proto_msgTypes[5].OneofWrappers = []any{} + file_geyser_proto_msgTypes[6].OneofWrappers = []any{} + file_geyser_proto_msgTypes[7].OneofWrappers = []any{} + file_geyser_proto_msgTypes[12].OneofWrappers = []any{ + (*SubscribeUpdate_Account)(nil), + (*SubscribeUpdate_Slot)(nil), + (*SubscribeUpdate_Transaction)(nil), + (*SubscribeUpdate_TransactionStatus)(nil), + (*SubscribeUpdate_Block)(nil), + (*SubscribeUpdate_Ping)(nil), + (*SubscribeUpdate_Pong)(nil), + (*SubscribeUpdate_BlockMeta)(nil), + (*SubscribeUpdate_Entry)(nil), + } + file_geyser_proto_msgTypes[14].OneofWrappers = []any{} + file_geyser_proto_msgTypes[15].OneofWrappers = []any{} + file_geyser_proto_msgTypes[25].OneofWrappers = []any{} + file_geyser_proto_msgTypes[28].OneofWrappers = []any{} + file_geyser_proto_msgTypes[30].OneofWrappers = []any{} + file_geyser_proto_msgTypes[32].OneofWrappers = []any{} + file_geyser_proto_msgTypes[36].OneofWrappers = []any{} + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_geyser_proto_rawDesc), len(file_geyser_proto_rawDesc)), + NumEnums: 2, + NumMessages: 45, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_geyser_proto_goTypes, + DependencyIndexes: file_geyser_proto_depIdxs, + EnumInfos: file_geyser_proto_enumTypes, + MessageInfos: file_geyser_proto_msgTypes, + }.Build() + File_geyser_proto = out.File + file_geyser_proto_goTypes = nil + file_geyser_proto_depIdxs = nil +} diff --git a/pkg/grpc/pb/geyser.proto b/pkg/grpc/pb/geyser.proto new file mode 100644 index 00000000..00320bcb --- /dev/null +++ b/pkg/grpc/pb/geyser.proto @@ -0,0 +1,279 @@ +syntax = "proto3"; + +import "google/protobuf/timestamp.proto"; +import "solana-storage.proto"; + +option go_package = "github.com/Overclock-Validator/mithril/pkg/grpc/pb"; + +package geyser; + +service Geyser { + rpc Subscribe(stream SubscribeRequest) returns (stream SubscribeUpdate) {} + rpc SubscribeReplayInfo(SubscribeReplayInfoRequest) returns (SubscribeReplayInfoResponse) {} + rpc Ping(PingRequest) returns (PongResponse) {} + rpc GetLatestBlockhash(GetLatestBlockhashRequest) returns (GetLatestBlockhashResponse) {} + rpc GetBlockHeight(GetBlockHeightRequest) returns (GetBlockHeightResponse) {} + rpc GetSlot(GetSlotRequest) returns (GetSlotResponse) {} + rpc IsBlockhashValid(IsBlockhashValidRequest) returns (IsBlockhashValidResponse) {} + rpc GetVersion(GetVersionRequest) returns (GetVersionResponse) {} +} + +enum CommitmentLevel { + PROCESSED = 0; + CONFIRMED = 1; + FINALIZED = 2; +} + +enum SlotStatus { + SLOT_PROCESSED = 0; + SLOT_CONFIRMED = 1; + SLOT_FINALIZED = 2; + SLOT_FIRST_SHRED_RECEIVED = 3; + SLOT_COMPLETED = 4; + SLOT_CREATED_BANK = 5; + SLOT_DEAD = 6; +} + +message SubscribeRequest { + map accounts = 1; + map slots = 2; + map transactions = 3; + map transactions_status = 10; + map blocks = 4; + map blocks_meta = 5; + map entry = 8; + optional CommitmentLevel commitment = 6; + repeated SubscribeRequestAccountsDataSlice accounts_data_slice = 7; + optional SubscribeRequestPing ping = 9; + optional uint64 from_slot = 11; +} + +message SubscribeRequestFilterAccounts { + repeated string account = 2; + repeated string owner = 3; + repeated SubscribeRequestFilterAccountsFilter filters = 4; + optional bool nonempty_txn_signature = 5; +} + +message SubscribeRequestFilterAccountsFilter { + oneof filter { + SubscribeRequestFilterAccountsFilterMemcmp memcmp = 1; + uint64 datasize = 2; + bool token_account_state = 3; + SubscribeRequestFilterAccountsFilterLamports lamports = 4; + } +} + +message SubscribeRequestFilterAccountsFilterMemcmp { + uint64 offset = 1; + oneof data { + bytes bytes = 2; + string base58 = 3; + string base64 = 4; + } +} + +message SubscribeRequestFilterAccountsFilterLamports { + oneof cmp { + uint64 eq = 1; + uint64 ne = 2; + uint64 lt = 3; + uint64 gt = 4; + } +} + +message SubscribeRequestFilterSlots { + optional bool filter_by_commitment = 1; + optional bool interslot_updates = 2; +} + +message SubscribeRequestFilterTransactions { + optional bool vote = 1; + optional bool failed = 2; + optional string signature = 5; + repeated string account_include = 3; + repeated string account_exclude = 4; + repeated string account_required = 6; +} + +message SubscribeRequestFilterBlocks { + repeated string account_include = 1; + optional bool include_transactions = 2; + optional bool include_accounts = 3; + optional bool include_entries = 4; +} + +message SubscribeRequestFilterBlocksMeta {} + +message SubscribeRequestFilterEntry {} + +message SubscribeRequestAccountsDataSlice { + uint64 offset = 1; + uint64 length = 2; +} + +message SubscribeRequestPing { + int32 id = 1; +} + +message SubscribeUpdate { + repeated string filters = 1; + oneof update_oneof { + SubscribeUpdateAccount account = 2; + SubscribeUpdateSlot slot = 3; + SubscribeUpdateTransaction transaction = 4; + SubscribeUpdateTransactionStatus transaction_status = 10; + SubscribeUpdateBlock block = 5; + SubscribeUpdatePing ping = 6; + SubscribeUpdatePong pong = 9; + SubscribeUpdateBlockMeta block_meta = 7; + SubscribeUpdateEntry entry = 8; + } + google.protobuf.Timestamp created_at = 11; +} + +message SubscribeUpdateAccount { + SubscribeUpdateAccountInfo account = 1; + uint64 slot = 2; + bool is_startup = 3; +} + +message SubscribeUpdateAccountInfo { + bytes pubkey = 1; + uint64 lamports = 2; + bytes owner = 3; + bool executable = 4; + uint64 rent_epoch = 5; + bytes data = 6; + uint64 write_version = 7; + optional bytes txn_signature = 8; +} + +message SubscribeUpdateSlot { + uint64 slot = 1; + optional uint64 parent = 2; + SlotStatus status = 3; + optional string dead_error = 4; +} + +message SubscribeUpdateTransaction { + SubscribeUpdateTransactionInfo transaction = 1; + uint64 slot = 2; +} + +message SubscribeUpdateTransactionInfo { + bytes signature = 1; + bool is_vote = 2; + solana.storage.ConfirmedBlock.Transaction transaction = 3; + solana.storage.ConfirmedBlock.TransactionStatusMeta meta = 4; + uint64 index = 5; +} + +message SubscribeUpdateTransactionStatus { + uint64 slot = 1; + bytes signature = 2; + bool is_vote = 3; + uint64 index = 4; + solana.storage.ConfirmedBlock.TransactionError err = 5; +} + +message SubscribeUpdateBlock { + uint64 slot = 1; + string blockhash = 2; + solana.storage.ConfirmedBlock.Rewards rewards = 3; + solana.storage.ConfirmedBlock.UnixTimestamp block_time = 4; + solana.storage.ConfirmedBlock.BlockHeight block_height = 5; + uint64 parent_slot = 7; + string parent_blockhash = 8; + uint64 executed_transaction_count = 9; + repeated SubscribeUpdateTransactionInfo transactions = 6; + uint64 updated_account_count = 10; + repeated SubscribeUpdateAccountInfo accounts = 11; + uint64 entries_count = 12; + repeated SubscribeUpdateEntry entries = 13; +} + +message SubscribeUpdateBlockMeta { + uint64 slot = 1; + string blockhash = 2; + solana.storage.ConfirmedBlock.Rewards rewards = 3; + solana.storage.ConfirmedBlock.UnixTimestamp block_time = 4; + solana.storage.ConfirmedBlock.BlockHeight block_height = 5; + uint64 parent_slot = 6; + string parent_blockhash = 7; + uint64 executed_transaction_count = 8; + uint64 entries_count = 9; +} + +message SubscribeUpdateEntry { + uint64 slot = 1; + uint64 index = 2; + uint64 num_hashes = 3; + bytes hash = 4; + uint64 executed_transaction_count = 5; + uint64 starting_transaction_index = 6; // added in v1.18, for solana 1.17 value is always 0 +} + +message SubscribeUpdatePing {} + +message SubscribeUpdatePong { + int32 id = 1; +} + +// non-streaming methods + +message SubscribeReplayInfoRequest {} + +message SubscribeReplayInfoResponse { + optional uint64 first_available = 1; +} + +message PingRequest { + int32 count = 1; +} + +message PongResponse { + int32 count = 1; +} + +message GetLatestBlockhashRequest { + optional CommitmentLevel commitment = 1; +} + +message GetLatestBlockhashResponse { + uint64 slot = 1; + string blockhash = 2; + uint64 last_valid_block_height = 3; +} + +message GetBlockHeightRequest { + optional CommitmentLevel commitment = 1; +} + +message GetBlockHeightResponse { + uint64 block_height = 1; +} + +message GetSlotRequest { + optional CommitmentLevel commitment = 1; +} + +message GetSlotResponse { + uint64 slot = 1; +} + +message GetVersionRequest {} + +message GetVersionResponse { + string version = 1; +} + +message IsBlockhashValidRequest { + string blockhash = 1; + optional CommitmentLevel commitment = 2; +} + +message IsBlockhashValidResponse { + uint64 slot = 1; + bool valid = 2; +} diff --git a/pkg/grpc/pb/geyser_grpc.pb.go b/pkg/grpc/pb/geyser_grpc.pb.go new file mode 100644 index 00000000..ab27fadd --- /dev/null +++ b/pkg/grpc/pb/geyser_grpc.pb.go @@ -0,0 +1,382 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.6.0 +// - protoc v5.28.0 +// source: geyser.proto + +package pb + +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 ( + Geyser_Subscribe_FullMethodName = "/geyser.Geyser/Subscribe" + Geyser_SubscribeReplayInfo_FullMethodName = "/geyser.Geyser/SubscribeReplayInfo" + Geyser_Ping_FullMethodName = "/geyser.Geyser/Ping" + Geyser_GetLatestBlockhash_FullMethodName = "/geyser.Geyser/GetLatestBlockhash" + Geyser_GetBlockHeight_FullMethodName = "/geyser.Geyser/GetBlockHeight" + Geyser_GetSlot_FullMethodName = "/geyser.Geyser/GetSlot" + Geyser_IsBlockhashValid_FullMethodName = "/geyser.Geyser/IsBlockhashValid" + Geyser_GetVersion_FullMethodName = "/geyser.Geyser/GetVersion" +) + +// 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 { + Subscribe(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[SubscribeRequest, SubscribeUpdate], error) + SubscribeReplayInfo(ctx context.Context, in *SubscribeReplayInfoRequest, opts ...grpc.CallOption) (*SubscribeReplayInfoResponse, error) + Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error) + GetLatestBlockhash(ctx context.Context, in *GetLatestBlockhashRequest, opts ...grpc.CallOption) (*GetLatestBlockhashResponse, error) + GetBlockHeight(ctx context.Context, in *GetBlockHeightRequest, opts ...grpc.CallOption) (*GetBlockHeightResponse, error) + GetSlot(ctx context.Context, in *GetSlotRequest, opts ...grpc.CallOption) (*GetSlotResponse, error) + IsBlockhashValid(ctx context.Context, in *IsBlockhashValidRequest, opts ...grpc.CallOption) (*IsBlockhashValidResponse, error) + GetVersion(ctx context.Context, in *GetVersionRequest, opts ...grpc.CallOption) (*GetVersionResponse, error) +} + +type geyserClient struct { + cc grpc.ClientConnInterface +} + +func NewGeyserClient(cc grpc.ClientConnInterface) GeyserClient { + return &geyserClient{cc} +} + +func (c *geyserClient) Subscribe(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[SubscribeRequest, SubscribeUpdate], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Geyser_ServiceDesc.Streams[0], Geyser_Subscribe_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[SubscribeRequest, SubscribeUpdate]{ClientStream: stream} + 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 Geyser_SubscribeClient = grpc.BidiStreamingClient[SubscribeRequest, SubscribeUpdate] + +func (c *geyserClient) SubscribeReplayInfo(ctx context.Context, in *SubscribeReplayInfoRequest, opts ...grpc.CallOption) (*SubscribeReplayInfoResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SubscribeReplayInfoResponse) + err := c.cc.Invoke(ctx, Geyser_SubscribeReplayInfo_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *geyserClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(PongResponse) + err := c.cc.Invoke(ctx, Geyser_Ping_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *geyserClient) GetLatestBlockhash(ctx context.Context, in *GetLatestBlockhashRequest, opts ...grpc.CallOption) (*GetLatestBlockhashResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetLatestBlockhashResponse) + err := c.cc.Invoke(ctx, Geyser_GetLatestBlockhash_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *geyserClient) GetBlockHeight(ctx context.Context, in *GetBlockHeightRequest, opts ...grpc.CallOption) (*GetBlockHeightResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetBlockHeightResponse) + err := c.cc.Invoke(ctx, Geyser_GetBlockHeight_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *geyserClient) GetSlot(ctx context.Context, in *GetSlotRequest, opts ...grpc.CallOption) (*GetSlotResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetSlotResponse) + err := c.cc.Invoke(ctx, Geyser_GetSlot_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *geyserClient) IsBlockhashValid(ctx context.Context, in *IsBlockhashValidRequest, opts ...grpc.CallOption) (*IsBlockhashValidResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IsBlockhashValidResponse) + err := c.cc.Invoke(ctx, Geyser_IsBlockhashValid_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *geyserClient) GetVersion(ctx context.Context, in *GetVersionRequest, opts ...grpc.CallOption) (*GetVersionResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetVersionResponse) + err := c.cc.Invoke(ctx, Geyser_GetVersion_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// GeyserServer is the server API for Geyser service. +// All implementations must embed UnimplementedGeyserServer +// for forward compatibility. +type GeyserServer interface { + Subscribe(grpc.BidiStreamingServer[SubscribeRequest, SubscribeUpdate]) error + SubscribeReplayInfo(context.Context, *SubscribeReplayInfoRequest) (*SubscribeReplayInfoResponse, error) + Ping(context.Context, *PingRequest) (*PongResponse, error) + GetLatestBlockhash(context.Context, *GetLatestBlockhashRequest) (*GetLatestBlockhashResponse, error) + GetBlockHeight(context.Context, *GetBlockHeightRequest) (*GetBlockHeightResponse, error) + GetSlot(context.Context, *GetSlotRequest) (*GetSlotResponse, error) + IsBlockhashValid(context.Context, *IsBlockhashValidRequest) (*IsBlockhashValidResponse, error) + GetVersion(context.Context, *GetVersionRequest) (*GetVersionResponse, error) + mustEmbedUnimplementedGeyserServer() +} + +// UnimplementedGeyserServer 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 UnimplementedGeyserServer struct{} + +func (UnimplementedGeyserServer) Subscribe(grpc.BidiStreamingServer[SubscribeRequest, SubscribeUpdate]) error { + return status.Error(codes.Unimplemented, "method Subscribe not implemented") +} +func (UnimplementedGeyserServer) SubscribeReplayInfo(context.Context, *SubscribeReplayInfoRequest) (*SubscribeReplayInfoResponse, error) { + return nil, status.Error(codes.Unimplemented, "method SubscribeReplayInfo not implemented") +} +func (UnimplementedGeyserServer) Ping(context.Context, *PingRequest) (*PongResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Ping not implemented") +} +func (UnimplementedGeyserServer) GetLatestBlockhash(context.Context, *GetLatestBlockhashRequest) (*GetLatestBlockhashResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetLatestBlockhash not implemented") +} +func (UnimplementedGeyserServer) GetBlockHeight(context.Context, *GetBlockHeightRequest) (*GetBlockHeightResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetBlockHeight not implemented") +} +func (UnimplementedGeyserServer) GetSlot(context.Context, *GetSlotRequest) (*GetSlotResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetSlot not implemented") +} +func (UnimplementedGeyserServer) IsBlockhashValid(context.Context, *IsBlockhashValidRequest) (*IsBlockhashValidResponse, error) { + return nil, status.Error(codes.Unimplemented, "method IsBlockhashValid not implemented") +} +func (UnimplementedGeyserServer) GetVersion(context.Context, *GetVersionRequest) (*GetVersionResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetVersion not implemented") +} +func (UnimplementedGeyserServer) mustEmbedUnimplementedGeyserServer() {} +func (UnimplementedGeyserServer) testEmbeddedByValue() {} + +// 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) { + // If the following call panics, it indicates UnimplementedGeyserServer 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(&Geyser_ServiceDesc, srv) +} + +func _Geyser_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(GeyserServer).Subscribe(&grpc.GenericServerStream[SubscribeRequest, SubscribeUpdate]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Geyser_SubscribeServer = grpc.BidiStreamingServer[SubscribeRequest, SubscribeUpdate] + +func _Geyser_SubscribeReplayInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SubscribeReplayInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeyserServer).SubscribeReplayInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Geyser_SubscribeReplayInfo_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeyserServer).SubscribeReplayInfo(ctx, req.(*SubscribeReplayInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Geyser_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeyserServer).Ping(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Geyser_Ping_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeyserServer).Ping(ctx, req.(*PingRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Geyser_GetLatestBlockhash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetLatestBlockhashRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeyserServer).GetLatestBlockhash(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Geyser_GetLatestBlockhash_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeyserServer).GetLatestBlockhash(ctx, req.(*GetLatestBlockhashRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Geyser_GetBlockHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetBlockHeightRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeyserServer).GetBlockHeight(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Geyser_GetBlockHeight_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeyserServer).GetBlockHeight(ctx, req.(*GetBlockHeightRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Geyser_GetSlot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetSlotRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeyserServer).GetSlot(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Geyser_GetSlot_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeyserServer).GetSlot(ctx, req.(*GetSlotRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Geyser_IsBlockhashValid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(IsBlockhashValidRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeyserServer).IsBlockhashValid(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Geyser_IsBlockhashValid_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeyserServer).IsBlockhashValid(ctx, req.(*IsBlockhashValidRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Geyser_GetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetVersionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeyserServer).GetVersion(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Geyser_GetVersion_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeyserServer).GetVersion(ctx, req.(*GetVersionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// 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: "geyser.Geyser", + HandlerType: (*GeyserServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "SubscribeReplayInfo", + Handler: _Geyser_SubscribeReplayInfo_Handler, + }, + { + MethodName: "Ping", + Handler: _Geyser_Ping_Handler, + }, + { + MethodName: "GetLatestBlockhash", + Handler: _Geyser_GetLatestBlockhash_Handler, + }, + { + MethodName: "GetBlockHeight", + Handler: _Geyser_GetBlockHeight_Handler, + }, + { + MethodName: "GetSlot", + Handler: _Geyser_GetSlot_Handler, + }, + { + MethodName: "IsBlockhashValid", + Handler: _Geyser_IsBlockhashValid_Handler, + }, + { + MethodName: "GetVersion", + Handler: _Geyser_GetVersion_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "Subscribe", + Handler: _Geyser_Subscribe_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: "geyser.proto", +} diff --git a/pkg/grpc/pb/solana-storage.pb.go b/pkg/grpc/pb/solana-storage.pb.go new file mode 100644 index 00000000..baf93989 --- /dev/null +++ b/pkg/grpc/pb/solana-storage.pb.go @@ -0,0 +1,1559 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.10 +// protoc v5.28.0 +// source: solana-storage.proto + +package pb + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +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) +) + +type RewardType int32 + +const ( + RewardType_Unspecified RewardType = 0 + RewardType_Fee RewardType = 1 + RewardType_Rent RewardType = 2 + RewardType_Staking RewardType = 3 + RewardType_Voting RewardType = 4 +) + +// Enum value maps for RewardType. +var ( + RewardType_name = map[int32]string{ + 0: "Unspecified", + 1: "Fee", + 2: "Rent", + 3: "Staking", + 4: "Voting", + } + RewardType_value = map[string]int32{ + "Unspecified": 0, + "Fee": 1, + "Rent": 2, + "Staking": 3, + "Voting": 4, + } +) + +func (x RewardType) Enum() *RewardType { + p := new(RewardType) + *p = x + return p +} + +func (x RewardType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (RewardType) Descriptor() protoreflect.EnumDescriptor { + return file_solana_storage_proto_enumTypes[0].Descriptor() +} + +func (RewardType) Type() protoreflect.EnumType { + return &file_solana_storage_proto_enumTypes[0] +} + +func (x RewardType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use RewardType.Descriptor instead. +func (RewardType) EnumDescriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{0} +} + +type ConfirmedBlock struct { + state protoimpl.MessageState `protogen:"open.v1"` + PreviousBlockhash string `protobuf:"bytes,1,opt,name=previous_blockhash,json=previousBlockhash,proto3" json:"previous_blockhash,omitempty"` + Blockhash string `protobuf:"bytes,2,opt,name=blockhash,proto3" json:"blockhash,omitempty"` + ParentSlot uint64 `protobuf:"varint,3,opt,name=parent_slot,json=parentSlot,proto3" json:"parent_slot,omitempty"` + Transactions []*ConfirmedTransaction `protobuf:"bytes,4,rep,name=transactions,proto3" json:"transactions,omitempty"` + Rewards []*Reward `protobuf:"bytes,5,rep,name=rewards,proto3" json:"rewards,omitempty"` + BlockTime *UnixTimestamp `protobuf:"bytes,6,opt,name=block_time,json=blockTime,proto3" json:"block_time,omitempty"` + BlockHeight *BlockHeight `protobuf:"bytes,7,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` + NumPartitions *NumPartitions `protobuf:"bytes,8,opt,name=num_partitions,json=numPartitions,proto3" json:"num_partitions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ConfirmedBlock) Reset() { + *x = ConfirmedBlock{} + mi := &file_solana_storage_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ConfirmedBlock) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConfirmedBlock) ProtoMessage() {} + +func (x *ConfirmedBlock) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ConfirmedBlock.ProtoReflect.Descriptor instead. +func (*ConfirmedBlock) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{0} +} + +func (x *ConfirmedBlock) GetPreviousBlockhash() string { + if x != nil { + return x.PreviousBlockhash + } + return "" +} + +func (x *ConfirmedBlock) GetBlockhash() string { + if x != nil { + return x.Blockhash + } + return "" +} + +func (x *ConfirmedBlock) GetParentSlot() uint64 { + if x != nil { + return x.ParentSlot + } + return 0 +} + +func (x *ConfirmedBlock) GetTransactions() []*ConfirmedTransaction { + if x != nil { + return x.Transactions + } + return nil +} + +func (x *ConfirmedBlock) GetRewards() []*Reward { + if x != nil { + return x.Rewards + } + return nil +} + +func (x *ConfirmedBlock) GetBlockTime() *UnixTimestamp { + if x != nil { + return x.BlockTime + } + return nil +} + +func (x *ConfirmedBlock) GetBlockHeight() *BlockHeight { + if x != nil { + return x.BlockHeight + } + return nil +} + +func (x *ConfirmedBlock) GetNumPartitions() *NumPartitions { + if x != nil { + return x.NumPartitions + } + return nil +} + +type ConfirmedTransaction struct { + state protoimpl.MessageState `protogen:"open.v1"` + Transaction *Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"` + Meta *TransactionStatusMeta `protobuf:"bytes,2,opt,name=meta,proto3" json:"meta,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ConfirmedTransaction) Reset() { + *x = ConfirmedTransaction{} + mi := &file_solana_storage_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ConfirmedTransaction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConfirmedTransaction) ProtoMessage() {} + +func (x *ConfirmedTransaction) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ConfirmedTransaction.ProtoReflect.Descriptor instead. +func (*ConfirmedTransaction) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{1} +} + +func (x *ConfirmedTransaction) GetTransaction() *Transaction { + if x != nil { + return x.Transaction + } + return nil +} + +func (x *ConfirmedTransaction) GetMeta() *TransactionStatusMeta { + if x != nil { + return x.Meta + } + return nil +} + +type Transaction struct { + state protoimpl.MessageState `protogen:"open.v1"` + Signatures [][]byte `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"` + Message *Message `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Transaction) Reset() { + *x = Transaction{} + mi := &file_solana_storage_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Transaction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Transaction) ProtoMessage() {} + +func (x *Transaction) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Transaction.ProtoReflect.Descriptor instead. +func (*Transaction) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{2} +} + +func (x *Transaction) GetSignatures() [][]byte { + if x != nil { + return x.Signatures + } + return nil +} + +func (x *Transaction) GetMessage() *Message { + if x != nil { + return x.Message + } + return nil +} + +type Message struct { + state protoimpl.MessageState `protogen:"open.v1"` + Header *MessageHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + AccountKeys [][]byte `protobuf:"bytes,2,rep,name=account_keys,json=accountKeys,proto3" json:"account_keys,omitempty"` + RecentBlockhash []byte `protobuf:"bytes,3,opt,name=recent_blockhash,json=recentBlockhash,proto3" json:"recent_blockhash,omitempty"` + Instructions []*CompiledInstruction `protobuf:"bytes,4,rep,name=instructions,proto3" json:"instructions,omitempty"` + Versioned bool `protobuf:"varint,5,opt,name=versioned,proto3" json:"versioned,omitempty"` + AddressTableLookups []*MessageAddressTableLookup `protobuf:"bytes,6,rep,name=address_table_lookups,json=addressTableLookups,proto3" json:"address_table_lookups,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Message) Reset() { + *x = Message{} + mi := &file_solana_storage_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Message) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Message) ProtoMessage() {} + +func (x *Message) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Message.ProtoReflect.Descriptor instead. +func (*Message) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{3} +} + +func (x *Message) GetHeader() *MessageHeader { + if x != nil { + return x.Header + } + return nil +} + +func (x *Message) GetAccountKeys() [][]byte { + if x != nil { + return x.AccountKeys + } + return nil +} + +func (x *Message) GetRecentBlockhash() []byte { + if x != nil { + return x.RecentBlockhash + } + return nil +} + +func (x *Message) GetInstructions() []*CompiledInstruction { + if x != nil { + return x.Instructions + } + return nil +} + +func (x *Message) GetVersioned() bool { + if x != nil { + return x.Versioned + } + return false +} + +func (x *Message) GetAddressTableLookups() []*MessageAddressTableLookup { + if x != nil { + return x.AddressTableLookups + } + return nil +} + +type MessageHeader struct { + state protoimpl.MessageState `protogen:"open.v1"` + NumRequiredSignatures uint32 `protobuf:"varint,1,opt,name=num_required_signatures,json=numRequiredSignatures,proto3" json:"num_required_signatures,omitempty"` + NumReadonlySignedAccounts uint32 `protobuf:"varint,2,opt,name=num_readonly_signed_accounts,json=numReadonlySignedAccounts,proto3" json:"num_readonly_signed_accounts,omitempty"` + NumReadonlyUnsignedAccounts uint32 `protobuf:"varint,3,opt,name=num_readonly_unsigned_accounts,json=numReadonlyUnsignedAccounts,proto3" json:"num_readonly_unsigned_accounts,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MessageHeader) Reset() { + *x = MessageHeader{} + mi := &file_solana_storage_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MessageHeader) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MessageHeader) ProtoMessage() {} + +func (x *MessageHeader) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MessageHeader.ProtoReflect.Descriptor instead. +func (*MessageHeader) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{4} +} + +func (x *MessageHeader) GetNumRequiredSignatures() uint32 { + if x != nil { + return x.NumRequiredSignatures + } + return 0 +} + +func (x *MessageHeader) GetNumReadonlySignedAccounts() uint32 { + if x != nil { + return x.NumReadonlySignedAccounts + } + return 0 +} + +func (x *MessageHeader) GetNumReadonlyUnsignedAccounts() uint32 { + if x != nil { + return x.NumReadonlyUnsignedAccounts + } + return 0 +} + +type MessageAddressTableLookup struct { + state protoimpl.MessageState `protogen:"open.v1"` + AccountKey []byte `protobuf:"bytes,1,opt,name=account_key,json=accountKey,proto3" json:"account_key,omitempty"` + WritableIndexes []byte `protobuf:"bytes,2,opt,name=writable_indexes,json=writableIndexes,proto3" json:"writable_indexes,omitempty"` + ReadonlyIndexes []byte `protobuf:"bytes,3,opt,name=readonly_indexes,json=readonlyIndexes,proto3" json:"readonly_indexes,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MessageAddressTableLookup) Reset() { + *x = MessageAddressTableLookup{} + mi := &file_solana_storage_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MessageAddressTableLookup) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MessageAddressTableLookup) ProtoMessage() {} + +func (x *MessageAddressTableLookup) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MessageAddressTableLookup.ProtoReflect.Descriptor instead. +func (*MessageAddressTableLookup) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{5} +} + +func (x *MessageAddressTableLookup) GetAccountKey() []byte { + if x != nil { + return x.AccountKey + } + return nil +} + +func (x *MessageAddressTableLookup) GetWritableIndexes() []byte { + if x != nil { + return x.WritableIndexes + } + return nil +} + +func (x *MessageAddressTableLookup) GetReadonlyIndexes() []byte { + if x != nil { + return x.ReadonlyIndexes + } + return nil +} + +type TransactionStatusMeta struct { + state protoimpl.MessageState `protogen:"open.v1"` + Err *TransactionError `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"` + Fee uint64 `protobuf:"varint,2,opt,name=fee,proto3" json:"fee,omitempty"` + PreBalances []uint64 `protobuf:"varint,3,rep,packed,name=pre_balances,json=preBalances,proto3" json:"pre_balances,omitempty"` + PostBalances []uint64 `protobuf:"varint,4,rep,packed,name=post_balances,json=postBalances,proto3" json:"post_balances,omitempty"` + InnerInstructions []*InnerInstructions `protobuf:"bytes,5,rep,name=inner_instructions,json=innerInstructions,proto3" json:"inner_instructions,omitempty"` + InnerInstructionsNone bool `protobuf:"varint,10,opt,name=inner_instructions_none,json=innerInstructionsNone,proto3" json:"inner_instructions_none,omitempty"` + LogMessages []string `protobuf:"bytes,6,rep,name=log_messages,json=logMessages,proto3" json:"log_messages,omitempty"` + LogMessagesNone bool `protobuf:"varint,11,opt,name=log_messages_none,json=logMessagesNone,proto3" json:"log_messages_none,omitempty"` + PreTokenBalances []*TokenBalance `protobuf:"bytes,7,rep,name=pre_token_balances,json=preTokenBalances,proto3" json:"pre_token_balances,omitempty"` + PostTokenBalances []*TokenBalance `protobuf:"bytes,8,rep,name=post_token_balances,json=postTokenBalances,proto3" json:"post_token_balances,omitempty"` + Rewards []*Reward `protobuf:"bytes,9,rep,name=rewards,proto3" json:"rewards,omitempty"` + LoadedWritableAddresses [][]byte `protobuf:"bytes,12,rep,name=loaded_writable_addresses,json=loadedWritableAddresses,proto3" json:"loaded_writable_addresses,omitempty"` + LoadedReadonlyAddresses [][]byte `protobuf:"bytes,13,rep,name=loaded_readonly_addresses,json=loadedReadonlyAddresses,proto3" json:"loaded_readonly_addresses,omitempty"` + ReturnData *ReturnData `protobuf:"bytes,14,opt,name=return_data,json=returnData,proto3" json:"return_data,omitempty"` + ReturnDataNone bool `protobuf:"varint,15,opt,name=return_data_none,json=returnDataNone,proto3" json:"return_data_none,omitempty"` + // Sum of compute units consumed by all instructions. + // Available since Solana v1.10.35 / v1.11.6. + // Set to `None` for txs executed on earlier versions. + ComputeUnitsConsumed *uint64 `protobuf:"varint,16,opt,name=compute_units_consumed,json=computeUnitsConsumed,proto3,oneof" json:"compute_units_consumed,omitempty"` + // Total transaction cost + CostUnits *uint64 `protobuf:"varint,17,opt,name=cost_units,json=costUnits,proto3,oneof" json:"cost_units,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TransactionStatusMeta) Reset() { + *x = TransactionStatusMeta{} + mi := &file_solana_storage_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TransactionStatusMeta) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TransactionStatusMeta) ProtoMessage() {} + +func (x *TransactionStatusMeta) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TransactionStatusMeta.ProtoReflect.Descriptor instead. +func (*TransactionStatusMeta) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{6} +} + +func (x *TransactionStatusMeta) GetErr() *TransactionError { + if x != nil { + return x.Err + } + return nil +} + +func (x *TransactionStatusMeta) GetFee() uint64 { + if x != nil { + return x.Fee + } + return 0 +} + +func (x *TransactionStatusMeta) GetPreBalances() []uint64 { + if x != nil { + return x.PreBalances + } + return nil +} + +func (x *TransactionStatusMeta) GetPostBalances() []uint64 { + if x != nil { + return x.PostBalances + } + return nil +} + +func (x *TransactionStatusMeta) GetInnerInstructions() []*InnerInstructions { + if x != nil { + return x.InnerInstructions + } + return nil +} + +func (x *TransactionStatusMeta) GetInnerInstructionsNone() bool { + if x != nil { + return x.InnerInstructionsNone + } + return false +} + +func (x *TransactionStatusMeta) GetLogMessages() []string { + if x != nil { + return x.LogMessages + } + return nil +} + +func (x *TransactionStatusMeta) GetLogMessagesNone() bool { + if x != nil { + return x.LogMessagesNone + } + return false +} + +func (x *TransactionStatusMeta) GetPreTokenBalances() []*TokenBalance { + if x != nil { + return x.PreTokenBalances + } + return nil +} + +func (x *TransactionStatusMeta) GetPostTokenBalances() []*TokenBalance { + if x != nil { + return x.PostTokenBalances + } + return nil +} + +func (x *TransactionStatusMeta) GetRewards() []*Reward { + if x != nil { + return x.Rewards + } + return nil +} + +func (x *TransactionStatusMeta) GetLoadedWritableAddresses() [][]byte { + if x != nil { + return x.LoadedWritableAddresses + } + return nil +} + +func (x *TransactionStatusMeta) GetLoadedReadonlyAddresses() [][]byte { + if x != nil { + return x.LoadedReadonlyAddresses + } + return nil +} + +func (x *TransactionStatusMeta) GetReturnData() *ReturnData { + if x != nil { + return x.ReturnData + } + return nil +} + +func (x *TransactionStatusMeta) GetReturnDataNone() bool { + if x != nil { + return x.ReturnDataNone + } + return false +} + +func (x *TransactionStatusMeta) GetComputeUnitsConsumed() uint64 { + if x != nil && x.ComputeUnitsConsumed != nil { + return *x.ComputeUnitsConsumed + } + return 0 +} + +func (x *TransactionStatusMeta) GetCostUnits() uint64 { + if x != nil && x.CostUnits != nil { + return *x.CostUnits + } + return 0 +} + +type TransactionError struct { + state protoimpl.MessageState `protogen:"open.v1"` + Err []byte `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TransactionError) Reset() { + *x = TransactionError{} + mi := &file_solana_storage_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TransactionError) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TransactionError) ProtoMessage() {} + +func (x *TransactionError) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TransactionError.ProtoReflect.Descriptor instead. +func (*TransactionError) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{7} +} + +func (x *TransactionError) GetErr() []byte { + if x != nil { + return x.Err + } + return nil +} + +type InnerInstructions struct { + state protoimpl.MessageState `protogen:"open.v1"` + Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + Instructions []*InnerInstruction `protobuf:"bytes,2,rep,name=instructions,proto3" json:"instructions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InnerInstructions) Reset() { + *x = InnerInstructions{} + mi := &file_solana_storage_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InnerInstructions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InnerInstructions) ProtoMessage() {} + +func (x *InnerInstructions) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InnerInstructions.ProtoReflect.Descriptor instead. +func (*InnerInstructions) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{8} +} + +func (x *InnerInstructions) GetIndex() uint32 { + if x != nil { + return x.Index + } + return 0 +} + +func (x *InnerInstructions) GetInstructions() []*InnerInstruction { + if x != nil { + return x.Instructions + } + return nil +} + +type InnerInstruction struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProgramIdIndex uint32 `protobuf:"varint,1,opt,name=program_id_index,json=programIdIndex,proto3" json:"program_id_index,omitempty"` + Accounts []byte `protobuf:"bytes,2,opt,name=accounts,proto3" json:"accounts,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + // Invocation stack height of an inner instruction. + // Available since Solana v1.14.6 + // Set to `None` for txs executed on earlier versions. + StackHeight *uint32 `protobuf:"varint,4,opt,name=stack_height,json=stackHeight,proto3,oneof" json:"stack_height,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InnerInstruction) Reset() { + *x = InnerInstruction{} + mi := &file_solana_storage_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InnerInstruction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InnerInstruction) ProtoMessage() {} + +func (x *InnerInstruction) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InnerInstruction.ProtoReflect.Descriptor instead. +func (*InnerInstruction) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{9} +} + +func (x *InnerInstruction) GetProgramIdIndex() uint32 { + if x != nil { + return x.ProgramIdIndex + } + return 0 +} + +func (x *InnerInstruction) GetAccounts() []byte { + if x != nil { + return x.Accounts + } + return nil +} + +func (x *InnerInstruction) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *InnerInstruction) GetStackHeight() uint32 { + if x != nil && x.StackHeight != nil { + return *x.StackHeight + } + return 0 +} + +type CompiledInstruction struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProgramIdIndex uint32 `protobuf:"varint,1,opt,name=program_id_index,json=programIdIndex,proto3" json:"program_id_index,omitempty"` + Accounts []byte `protobuf:"bytes,2,opt,name=accounts,proto3" json:"accounts,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CompiledInstruction) Reset() { + *x = CompiledInstruction{} + mi := &file_solana_storage_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CompiledInstruction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CompiledInstruction) ProtoMessage() {} + +func (x *CompiledInstruction) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CompiledInstruction.ProtoReflect.Descriptor instead. +func (*CompiledInstruction) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{10} +} + +func (x *CompiledInstruction) GetProgramIdIndex() uint32 { + if x != nil { + return x.ProgramIdIndex + } + return 0 +} + +func (x *CompiledInstruction) GetAccounts() []byte { + if x != nil { + return x.Accounts + } + return nil +} + +func (x *CompiledInstruction) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +type TokenBalance struct { + state protoimpl.MessageState `protogen:"open.v1"` + AccountIndex uint32 `protobuf:"varint,1,opt,name=account_index,json=accountIndex,proto3" json:"account_index,omitempty"` + Mint string `protobuf:"bytes,2,opt,name=mint,proto3" json:"mint,omitempty"` + UiTokenAmount *UiTokenAmount `protobuf:"bytes,3,opt,name=ui_token_amount,json=uiTokenAmount,proto3" json:"ui_token_amount,omitempty"` + Owner string `protobuf:"bytes,4,opt,name=owner,proto3" json:"owner,omitempty"` + ProgramId string `protobuf:"bytes,5,opt,name=program_id,json=programId,proto3" json:"program_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TokenBalance) Reset() { + *x = TokenBalance{} + mi := &file_solana_storage_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TokenBalance) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TokenBalance) ProtoMessage() {} + +func (x *TokenBalance) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TokenBalance.ProtoReflect.Descriptor instead. +func (*TokenBalance) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{11} +} + +func (x *TokenBalance) GetAccountIndex() uint32 { + if x != nil { + return x.AccountIndex + } + return 0 +} + +func (x *TokenBalance) GetMint() string { + if x != nil { + return x.Mint + } + return "" +} + +func (x *TokenBalance) GetUiTokenAmount() *UiTokenAmount { + if x != nil { + return x.UiTokenAmount + } + return nil +} + +func (x *TokenBalance) GetOwner() string { + if x != nil { + return x.Owner + } + return "" +} + +func (x *TokenBalance) GetProgramId() string { + if x != nil { + return x.ProgramId + } + return "" +} + +type UiTokenAmount struct { + state protoimpl.MessageState `protogen:"open.v1"` + UiAmount float64 `protobuf:"fixed64,1,opt,name=ui_amount,json=uiAmount,proto3" json:"ui_amount,omitempty"` + Decimals uint32 `protobuf:"varint,2,opt,name=decimals,proto3" json:"decimals,omitempty"` + Amount string `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"` + UiAmountString string `protobuf:"bytes,4,opt,name=ui_amount_string,json=uiAmountString,proto3" json:"ui_amount_string,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UiTokenAmount) Reset() { + *x = UiTokenAmount{} + mi := &file_solana_storage_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UiTokenAmount) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UiTokenAmount) ProtoMessage() {} + +func (x *UiTokenAmount) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UiTokenAmount.ProtoReflect.Descriptor instead. +func (*UiTokenAmount) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{12} +} + +func (x *UiTokenAmount) GetUiAmount() float64 { + if x != nil { + return x.UiAmount + } + return 0 +} + +func (x *UiTokenAmount) GetDecimals() uint32 { + if x != nil { + return x.Decimals + } + return 0 +} + +func (x *UiTokenAmount) GetAmount() string { + if x != nil { + return x.Amount + } + return "" +} + +func (x *UiTokenAmount) GetUiAmountString() string { + if x != nil { + return x.UiAmountString + } + return "" +} + +type ReturnData struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProgramId []byte `protobuf:"bytes,1,opt,name=program_id,json=programId,proto3" json:"program_id,omitempty"` + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReturnData) Reset() { + *x = ReturnData{} + mi := &file_solana_storage_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReturnData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReturnData) ProtoMessage() {} + +func (x *ReturnData) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReturnData.ProtoReflect.Descriptor instead. +func (*ReturnData) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{13} +} + +func (x *ReturnData) GetProgramId() []byte { + if x != nil { + return x.ProgramId + } + return nil +} + +func (x *ReturnData) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +type Reward struct { + state protoimpl.MessageState `protogen:"open.v1"` + Pubkey string `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"` + Lamports int64 `protobuf:"varint,2,opt,name=lamports,proto3" json:"lamports,omitempty"` + PostBalance uint64 `protobuf:"varint,3,opt,name=post_balance,json=postBalance,proto3" json:"post_balance,omitempty"` + RewardType RewardType `protobuf:"varint,4,opt,name=reward_type,json=rewardType,proto3,enum=solana.storage.ConfirmedBlock.RewardType" json:"reward_type,omitempty"` + Commission string `protobuf:"bytes,5,opt,name=commission,proto3" json:"commission,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Reward) Reset() { + *x = Reward{} + mi := &file_solana_storage_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Reward) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Reward) ProtoMessage() {} + +func (x *Reward) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Reward.ProtoReflect.Descriptor instead. +func (*Reward) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{14} +} + +func (x *Reward) GetPubkey() string { + if x != nil { + return x.Pubkey + } + return "" +} + +func (x *Reward) GetLamports() int64 { + if x != nil { + return x.Lamports + } + return 0 +} + +func (x *Reward) GetPostBalance() uint64 { + if x != nil { + return x.PostBalance + } + return 0 +} + +func (x *Reward) GetRewardType() RewardType { + if x != nil { + return x.RewardType + } + return RewardType_Unspecified +} + +func (x *Reward) GetCommission() string { + if x != nil { + return x.Commission + } + return "" +} + +type Rewards struct { + state protoimpl.MessageState `protogen:"open.v1"` + Rewards []*Reward `protobuf:"bytes,1,rep,name=rewards,proto3" json:"rewards,omitempty"` + NumPartitions *NumPartitions `protobuf:"bytes,2,opt,name=num_partitions,json=numPartitions,proto3" json:"num_partitions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Rewards) Reset() { + *x = Rewards{} + mi := &file_solana_storage_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Rewards) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Rewards) ProtoMessage() {} + +func (x *Rewards) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[15] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Rewards.ProtoReflect.Descriptor instead. +func (*Rewards) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{15} +} + +func (x *Rewards) GetRewards() []*Reward { + if x != nil { + return x.Rewards + } + return nil +} + +func (x *Rewards) GetNumPartitions() *NumPartitions { + if x != nil { + return x.NumPartitions + } + return nil +} + +type UnixTimestamp struct { + state protoimpl.MessageState `protogen:"open.v1"` + Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UnixTimestamp) Reset() { + *x = UnixTimestamp{} + mi := &file_solana_storage_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UnixTimestamp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnixTimestamp) ProtoMessage() {} + +func (x *UnixTimestamp) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[16] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnixTimestamp.ProtoReflect.Descriptor instead. +func (*UnixTimestamp) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{16} +} + +func (x *UnixTimestamp) GetTimestamp() int64 { + if x != nil { + return x.Timestamp + } + return 0 +} + +type BlockHeight struct { + state protoimpl.MessageState `protogen:"open.v1"` + BlockHeight uint64 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BlockHeight) Reset() { + *x = BlockHeight{} + mi := &file_solana_storage_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BlockHeight) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlockHeight) ProtoMessage() {} + +func (x *BlockHeight) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[17] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlockHeight.ProtoReflect.Descriptor instead. +func (*BlockHeight) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{17} +} + +func (x *BlockHeight) GetBlockHeight() uint64 { + if x != nil { + return x.BlockHeight + } + return 0 +} + +type NumPartitions struct { + state protoimpl.MessageState `protogen:"open.v1"` + NumPartitions uint64 `protobuf:"varint,1,opt,name=num_partitions,json=numPartitions,proto3" json:"num_partitions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *NumPartitions) Reset() { + *x = NumPartitions{} + mi := &file_solana_storage_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *NumPartitions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NumPartitions) ProtoMessage() {} + +func (x *NumPartitions) ProtoReflect() protoreflect.Message { + mi := &file_solana_storage_proto_msgTypes[18] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NumPartitions.ProtoReflect.Descriptor instead. +func (*NumPartitions) Descriptor() ([]byte, []int) { + return file_solana_storage_proto_rawDescGZIP(), []int{18} +} + +func (x *NumPartitions) GetNumPartitions() uint64 { + if x != nil { + return x.NumPartitions + } + return 0 +} + +var File_solana_storage_proto protoreflect.FileDescriptor + +const file_solana_storage_proto_rawDesc = "" + + "\n" + + "\x14solana-storage.proto\x12\x1dsolana.storage.ConfirmedBlock\"\x89\x04\n" + + "\x0eConfirmedBlock\x12-\n" + + "\x12previous_blockhash\x18\x01 \x01(\tR\x11previousBlockhash\x12\x1c\n" + + "\tblockhash\x18\x02 \x01(\tR\tblockhash\x12\x1f\n" + + "\vparent_slot\x18\x03 \x01(\x04R\n" + + "parentSlot\x12W\n" + + "\ftransactions\x18\x04 \x03(\v23.solana.storage.ConfirmedBlock.ConfirmedTransactionR\ftransactions\x12?\n" + + "\arewards\x18\x05 \x03(\v2%.solana.storage.ConfirmedBlock.RewardR\arewards\x12K\n" + + "\n" + + "block_time\x18\x06 \x01(\v2,.solana.storage.ConfirmedBlock.UnixTimestampR\tblockTime\x12M\n" + + "\fblock_height\x18\a \x01(\v2*.solana.storage.ConfirmedBlock.BlockHeightR\vblockHeight\x12S\n" + + "\x0enum_partitions\x18\b \x01(\v2,.solana.storage.ConfirmedBlock.NumPartitionsR\rnumPartitions\"\xae\x01\n" + + "\x14ConfirmedTransaction\x12L\n" + + "\vtransaction\x18\x01 \x01(\v2*.solana.storage.ConfirmedBlock.TransactionR\vtransaction\x12H\n" + + "\x04meta\x18\x02 \x01(\v24.solana.storage.ConfirmedBlock.TransactionStatusMetaR\x04meta\"o\n" + + "\vTransaction\x12\x1e\n" + + "\n" + + "signatures\x18\x01 \x03(\fR\n" + + "signatures\x12@\n" + + "\amessage\x18\x02 \x01(\v2&.solana.storage.ConfirmedBlock.MessageR\amessage\"\x81\x03\n" + + "\aMessage\x12D\n" + + "\x06header\x18\x01 \x01(\v2,.solana.storage.ConfirmedBlock.MessageHeaderR\x06header\x12!\n" + + "\faccount_keys\x18\x02 \x03(\fR\vaccountKeys\x12)\n" + + "\x10recent_blockhash\x18\x03 \x01(\fR\x0frecentBlockhash\x12V\n" + + "\finstructions\x18\x04 \x03(\v22.solana.storage.ConfirmedBlock.CompiledInstructionR\finstructions\x12\x1c\n" + + "\tversioned\x18\x05 \x01(\bR\tversioned\x12l\n" + + "\x15address_table_lookups\x18\x06 \x03(\v28.solana.storage.ConfirmedBlock.MessageAddressTableLookupR\x13addressTableLookups\"\xcd\x01\n" + + "\rMessageHeader\x126\n" + + "\x17num_required_signatures\x18\x01 \x01(\rR\x15numRequiredSignatures\x12?\n" + + "\x1cnum_readonly_signed_accounts\x18\x02 \x01(\rR\x19numReadonlySignedAccounts\x12C\n" + + "\x1enum_readonly_unsigned_accounts\x18\x03 \x01(\rR\x1bnumReadonlyUnsignedAccounts\"\x92\x01\n" + + "\x19MessageAddressTableLookup\x12\x1f\n" + + "\vaccount_key\x18\x01 \x01(\fR\n" + + "accountKey\x12)\n" + + "\x10writable_indexes\x18\x02 \x01(\fR\x0fwritableIndexes\x12)\n" + + "\x10readonly_indexes\x18\x03 \x01(\fR\x0freadonlyIndexes\"\x8c\b\n" + + "\x15TransactionStatusMeta\x12A\n" + + "\x03err\x18\x01 \x01(\v2/.solana.storage.ConfirmedBlock.TransactionErrorR\x03err\x12\x10\n" + + "\x03fee\x18\x02 \x01(\x04R\x03fee\x12!\n" + + "\fpre_balances\x18\x03 \x03(\x04R\vpreBalances\x12#\n" + + "\rpost_balances\x18\x04 \x03(\x04R\fpostBalances\x12_\n" + + "\x12inner_instructions\x18\x05 \x03(\v20.solana.storage.ConfirmedBlock.InnerInstructionsR\x11innerInstructions\x126\n" + + "\x17inner_instructions_none\x18\n" + + " \x01(\bR\x15innerInstructionsNone\x12!\n" + + "\flog_messages\x18\x06 \x03(\tR\vlogMessages\x12*\n" + + "\x11log_messages_none\x18\v \x01(\bR\x0flogMessagesNone\x12Y\n" + + "\x12pre_token_balances\x18\a \x03(\v2+.solana.storage.ConfirmedBlock.TokenBalanceR\x10preTokenBalances\x12[\n" + + "\x13post_token_balances\x18\b \x03(\v2+.solana.storage.ConfirmedBlock.TokenBalanceR\x11postTokenBalances\x12?\n" + + "\arewards\x18\t \x03(\v2%.solana.storage.ConfirmedBlock.RewardR\arewards\x12:\n" + + "\x19loaded_writable_addresses\x18\f \x03(\fR\x17loadedWritableAddresses\x12:\n" + + "\x19loaded_readonly_addresses\x18\r \x03(\fR\x17loadedReadonlyAddresses\x12J\n" + + "\vreturn_data\x18\x0e \x01(\v2).solana.storage.ConfirmedBlock.ReturnDataR\n" + + "returnData\x12(\n" + + "\x10return_data_none\x18\x0f \x01(\bR\x0ereturnDataNone\x129\n" + + "\x16compute_units_consumed\x18\x10 \x01(\x04H\x00R\x14computeUnitsConsumed\x88\x01\x01\x12\"\n" + + "\n" + + "cost_units\x18\x11 \x01(\x04H\x01R\tcostUnits\x88\x01\x01B\x19\n" + + "\x17_compute_units_consumedB\r\n" + + "\v_cost_units\"$\n" + + "\x10TransactionError\x12\x10\n" + + "\x03err\x18\x01 \x01(\fR\x03err\"~\n" + + "\x11InnerInstructions\x12\x14\n" + + "\x05index\x18\x01 \x01(\rR\x05index\x12S\n" + + "\finstructions\x18\x02 \x03(\v2/.solana.storage.ConfirmedBlock.InnerInstructionR\finstructions\"\xa5\x01\n" + + "\x10InnerInstruction\x12(\n" + + "\x10program_id_index\x18\x01 \x01(\rR\x0eprogramIdIndex\x12\x1a\n" + + "\baccounts\x18\x02 \x01(\fR\baccounts\x12\x12\n" + + "\x04data\x18\x03 \x01(\fR\x04data\x12&\n" + + "\fstack_height\x18\x04 \x01(\rH\x00R\vstackHeight\x88\x01\x01B\x0f\n" + + "\r_stack_height\"o\n" + + "\x13CompiledInstruction\x12(\n" + + "\x10program_id_index\x18\x01 \x01(\rR\x0eprogramIdIndex\x12\x1a\n" + + "\baccounts\x18\x02 \x01(\fR\baccounts\x12\x12\n" + + "\x04data\x18\x03 \x01(\fR\x04data\"\xd2\x01\n" + + "\fTokenBalance\x12#\n" + + "\raccount_index\x18\x01 \x01(\rR\faccountIndex\x12\x12\n" + + "\x04mint\x18\x02 \x01(\tR\x04mint\x12T\n" + + "\x0fui_token_amount\x18\x03 \x01(\v2,.solana.storage.ConfirmedBlock.UiTokenAmountR\ruiTokenAmount\x12\x14\n" + + "\x05owner\x18\x04 \x01(\tR\x05owner\x12\x1d\n" + + "\n" + + "program_id\x18\x05 \x01(\tR\tprogramId\"\x8a\x01\n" + + "\rUiTokenAmount\x12\x1b\n" + + "\tui_amount\x18\x01 \x01(\x01R\buiAmount\x12\x1a\n" + + "\bdecimals\x18\x02 \x01(\rR\bdecimals\x12\x16\n" + + "\x06amount\x18\x03 \x01(\tR\x06amount\x12(\n" + + "\x10ui_amount_string\x18\x04 \x01(\tR\x0euiAmountString\"?\n" + + "\n" + + "ReturnData\x12\x1d\n" + + "\n" + + "program_id\x18\x01 \x01(\fR\tprogramId\x12\x12\n" + + "\x04data\x18\x02 \x01(\fR\x04data\"\xcb\x01\n" + + "\x06Reward\x12\x16\n" + + "\x06pubkey\x18\x01 \x01(\tR\x06pubkey\x12\x1a\n" + + "\blamports\x18\x02 \x01(\x03R\blamports\x12!\n" + + "\fpost_balance\x18\x03 \x01(\x04R\vpostBalance\x12J\n" + + "\vreward_type\x18\x04 \x01(\x0e2).solana.storage.ConfirmedBlock.RewardTypeR\n" + + "rewardType\x12\x1e\n" + + "\n" + + "commission\x18\x05 \x01(\tR\n" + + "commission\"\x9f\x01\n" + + "\aRewards\x12?\n" + + "\arewards\x18\x01 \x03(\v2%.solana.storage.ConfirmedBlock.RewardR\arewards\x12S\n" + + "\x0enum_partitions\x18\x02 \x01(\v2,.solana.storage.ConfirmedBlock.NumPartitionsR\rnumPartitions\"-\n" + + "\rUnixTimestamp\x12\x1c\n" + + "\ttimestamp\x18\x01 \x01(\x03R\ttimestamp\"0\n" + + "\vBlockHeight\x12!\n" + + "\fblock_height\x18\x01 \x01(\x04R\vblockHeight\"6\n" + + "\rNumPartitions\x12%\n" + + "\x0enum_partitions\x18\x01 \x01(\x04R\rnumPartitions*I\n" + + "\n" + + "RewardType\x12\x0f\n" + + "\vUnspecified\x10\x00\x12\a\n" + + "\x03Fee\x10\x01\x12\b\n" + + "\x04Rent\x10\x02\x12\v\n" + + "\aStaking\x10\x03\x12\n" + + "\n" + + "\x06Voting\x10\x04B4Z2github.com/Overclock-Validator/mithril/pkg/grpc/pbb\x06proto3" + +var ( + file_solana_storage_proto_rawDescOnce sync.Once + file_solana_storage_proto_rawDescData []byte +) + +func file_solana_storage_proto_rawDescGZIP() []byte { + file_solana_storage_proto_rawDescOnce.Do(func() { + file_solana_storage_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_solana_storage_proto_rawDesc), len(file_solana_storage_proto_rawDesc))) + }) + return file_solana_storage_proto_rawDescData +} + +var file_solana_storage_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_solana_storage_proto_msgTypes = make([]protoimpl.MessageInfo, 19) +var file_solana_storage_proto_goTypes = []any{ + (RewardType)(0), // 0: solana.storage.ConfirmedBlock.RewardType + (*ConfirmedBlock)(nil), // 1: solana.storage.ConfirmedBlock.ConfirmedBlock + (*ConfirmedTransaction)(nil), // 2: solana.storage.ConfirmedBlock.ConfirmedTransaction + (*Transaction)(nil), // 3: solana.storage.ConfirmedBlock.Transaction + (*Message)(nil), // 4: solana.storage.ConfirmedBlock.Message + (*MessageHeader)(nil), // 5: solana.storage.ConfirmedBlock.MessageHeader + (*MessageAddressTableLookup)(nil), // 6: solana.storage.ConfirmedBlock.MessageAddressTableLookup + (*TransactionStatusMeta)(nil), // 7: solana.storage.ConfirmedBlock.TransactionStatusMeta + (*TransactionError)(nil), // 8: solana.storage.ConfirmedBlock.TransactionError + (*InnerInstructions)(nil), // 9: solana.storage.ConfirmedBlock.InnerInstructions + (*InnerInstruction)(nil), // 10: solana.storage.ConfirmedBlock.InnerInstruction + (*CompiledInstruction)(nil), // 11: solana.storage.ConfirmedBlock.CompiledInstruction + (*TokenBalance)(nil), // 12: solana.storage.ConfirmedBlock.TokenBalance + (*UiTokenAmount)(nil), // 13: solana.storage.ConfirmedBlock.UiTokenAmount + (*ReturnData)(nil), // 14: solana.storage.ConfirmedBlock.ReturnData + (*Reward)(nil), // 15: solana.storage.ConfirmedBlock.Reward + (*Rewards)(nil), // 16: solana.storage.ConfirmedBlock.Rewards + (*UnixTimestamp)(nil), // 17: solana.storage.ConfirmedBlock.UnixTimestamp + (*BlockHeight)(nil), // 18: solana.storage.ConfirmedBlock.BlockHeight + (*NumPartitions)(nil), // 19: solana.storage.ConfirmedBlock.NumPartitions +} +var file_solana_storage_proto_depIdxs = []int32{ + 2, // 0: solana.storage.ConfirmedBlock.ConfirmedBlock.transactions:type_name -> solana.storage.ConfirmedBlock.ConfirmedTransaction + 15, // 1: solana.storage.ConfirmedBlock.ConfirmedBlock.rewards:type_name -> solana.storage.ConfirmedBlock.Reward + 17, // 2: solana.storage.ConfirmedBlock.ConfirmedBlock.block_time:type_name -> solana.storage.ConfirmedBlock.UnixTimestamp + 18, // 3: solana.storage.ConfirmedBlock.ConfirmedBlock.block_height:type_name -> solana.storage.ConfirmedBlock.BlockHeight + 19, // 4: solana.storage.ConfirmedBlock.ConfirmedBlock.num_partitions:type_name -> solana.storage.ConfirmedBlock.NumPartitions + 3, // 5: solana.storage.ConfirmedBlock.ConfirmedTransaction.transaction:type_name -> solana.storage.ConfirmedBlock.Transaction + 7, // 6: solana.storage.ConfirmedBlock.ConfirmedTransaction.meta:type_name -> solana.storage.ConfirmedBlock.TransactionStatusMeta + 4, // 7: solana.storage.ConfirmedBlock.Transaction.message:type_name -> solana.storage.ConfirmedBlock.Message + 5, // 8: solana.storage.ConfirmedBlock.Message.header:type_name -> solana.storage.ConfirmedBlock.MessageHeader + 11, // 9: solana.storage.ConfirmedBlock.Message.instructions:type_name -> solana.storage.ConfirmedBlock.CompiledInstruction + 6, // 10: solana.storage.ConfirmedBlock.Message.address_table_lookups:type_name -> solana.storage.ConfirmedBlock.MessageAddressTableLookup + 8, // 11: solana.storage.ConfirmedBlock.TransactionStatusMeta.err:type_name -> solana.storage.ConfirmedBlock.TransactionError + 9, // 12: solana.storage.ConfirmedBlock.TransactionStatusMeta.inner_instructions:type_name -> solana.storage.ConfirmedBlock.InnerInstructions + 12, // 13: solana.storage.ConfirmedBlock.TransactionStatusMeta.pre_token_balances:type_name -> solana.storage.ConfirmedBlock.TokenBalance + 12, // 14: solana.storage.ConfirmedBlock.TransactionStatusMeta.post_token_balances:type_name -> solana.storage.ConfirmedBlock.TokenBalance + 15, // 15: solana.storage.ConfirmedBlock.TransactionStatusMeta.rewards:type_name -> solana.storage.ConfirmedBlock.Reward + 14, // 16: solana.storage.ConfirmedBlock.TransactionStatusMeta.return_data:type_name -> solana.storage.ConfirmedBlock.ReturnData + 10, // 17: solana.storage.ConfirmedBlock.InnerInstructions.instructions:type_name -> solana.storage.ConfirmedBlock.InnerInstruction + 13, // 18: solana.storage.ConfirmedBlock.TokenBalance.ui_token_amount:type_name -> solana.storage.ConfirmedBlock.UiTokenAmount + 0, // 19: solana.storage.ConfirmedBlock.Reward.reward_type:type_name -> solana.storage.ConfirmedBlock.RewardType + 15, // 20: solana.storage.ConfirmedBlock.Rewards.rewards:type_name -> solana.storage.ConfirmedBlock.Reward + 19, // 21: solana.storage.ConfirmedBlock.Rewards.num_partitions:type_name -> solana.storage.ConfirmedBlock.NumPartitions + 22, // [22:22] is the sub-list for method output_type + 22, // [22:22] is the sub-list for method input_type + 22, // [22:22] is the sub-list for extension type_name + 22, // [22:22] is the sub-list for extension extendee + 0, // [0:22] is the sub-list for field type_name +} + +func init() { file_solana_storage_proto_init() } +func file_solana_storage_proto_init() { + if File_solana_storage_proto != nil { + return + } + file_solana_storage_proto_msgTypes[6].OneofWrappers = []any{} + file_solana_storage_proto_msgTypes[9].OneofWrappers = []any{} + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_solana_storage_proto_rawDesc), len(file_solana_storage_proto_rawDesc)), + NumEnums: 1, + NumMessages: 19, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_solana_storage_proto_goTypes, + DependencyIndexes: file_solana_storage_proto_depIdxs, + EnumInfos: file_solana_storage_proto_enumTypes, + MessageInfos: file_solana_storage_proto_msgTypes, + }.Build() + File_solana_storage_proto = out.File + file_solana_storage_proto_goTypes = nil + file_solana_storage_proto_depIdxs = nil +} diff --git a/pkg/grpc/pb/solana-storage.proto b/pkg/grpc/pb/solana-storage.proto new file mode 100644 index 00000000..9f285cc4 --- /dev/null +++ b/pkg/grpc/pb/solana-storage.proto @@ -0,0 +1,151 @@ +syntax = "proto3"; + +package solana.storage.ConfirmedBlock; + +option go_package = "github.com/Overclock-Validator/mithril/pkg/grpc/pb"; + +message ConfirmedBlock { + string previous_blockhash = 1; + string blockhash = 2; + uint64 parent_slot = 3; + repeated ConfirmedTransaction transactions = 4; + repeated Reward rewards = 5; + UnixTimestamp block_time = 6; + BlockHeight block_height = 7; + NumPartitions num_partitions = 8; +} + +message ConfirmedTransaction { + Transaction transaction = 1; + TransactionStatusMeta meta = 2; +} + +message Transaction { + repeated bytes signatures = 1; + Message message = 2; +} + +message Message { + MessageHeader header = 1; + repeated bytes account_keys = 2; + bytes recent_blockhash = 3; + repeated CompiledInstruction instructions = 4; + bool versioned = 5; + repeated MessageAddressTableLookup address_table_lookups = 6; +} + +message MessageHeader { + uint32 num_required_signatures = 1; + uint32 num_readonly_signed_accounts = 2; + uint32 num_readonly_unsigned_accounts = 3; +} + +message MessageAddressTableLookup { + bytes account_key = 1; + bytes writable_indexes = 2; + bytes readonly_indexes = 3; +} + +message TransactionStatusMeta { + TransactionError err = 1; + uint64 fee = 2; + repeated uint64 pre_balances = 3; + repeated uint64 post_balances = 4; + repeated InnerInstructions inner_instructions = 5; + bool inner_instructions_none = 10; + repeated string log_messages = 6; + bool log_messages_none = 11; + repeated TokenBalance pre_token_balances = 7; + repeated TokenBalance post_token_balances = 8; + repeated Reward rewards = 9; + repeated bytes loaded_writable_addresses = 12; + repeated bytes loaded_readonly_addresses = 13; + ReturnData return_data = 14; + bool return_data_none = 15; + + // Sum of compute units consumed by all instructions. + // Available since Solana v1.10.35 / v1.11.6. + // Set to `None` for txs executed on earlier versions. + optional uint64 compute_units_consumed = 16; + // Total transaction cost + optional uint64 cost_units = 17; +} + +message TransactionError { + bytes err = 1; +} + +message InnerInstructions { + uint32 index = 1; + repeated InnerInstruction instructions = 2; +} + +message InnerInstruction { + uint32 program_id_index = 1; + bytes accounts = 2; + bytes data = 3; + + // Invocation stack height of an inner instruction. + // Available since Solana v1.14.6 + // Set to `None` for txs executed on earlier versions. + optional uint32 stack_height = 4; +} + +message CompiledInstruction { + uint32 program_id_index = 1; + bytes accounts = 2; + bytes data = 3; +} + +message TokenBalance { + uint32 account_index = 1; + string mint = 2; + UiTokenAmount ui_token_amount = 3; + string owner = 4; + string program_id = 5; +} + +message UiTokenAmount { + double ui_amount = 1; + uint32 decimals = 2; + string amount = 3; + string ui_amount_string = 4; +} + +message ReturnData { + bytes program_id = 1; + bytes data = 2; +} + +enum RewardType { + Unspecified = 0; + Fee = 1; + Rent = 2; + Staking = 3; + Voting = 4; +} + +message Reward { + string pubkey = 1; + int64 lamports = 2; + uint64 post_balance = 3; + RewardType reward_type = 4; + string commission = 5; +} + +message Rewards { + repeated Reward rewards = 1; + NumPartitions num_partitions = 2; +} + +message UnixTimestamp { + int64 timestamp = 1; +} + +message BlockHeight { + uint64 block_height = 1; +} + +message NumPartitions { + uint64 num_partitions = 1; +} From 3855bf469253ba7d1b87811980ffe4adaf7933e7 Mon Sep 17 00:00:00 2001 From: dhruvsol Date: Sun, 30 Nov 2025 10:43:42 +0530 Subject: [PATCH 2/6] added update channel --- pkg/grpc/grpc.go | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/pkg/grpc/grpc.go b/pkg/grpc/grpc.go index d7b21c76..6035dc9b 100644 --- a/pkg/grpc/grpc.go +++ b/pkg/grpc/grpc.go @@ -40,3 +40,25 @@ func (s *GrpcServer) GracefulStop() { s.server.GracefulStop() } +// GetUpdateChannel returns the channel where SubscribeUpdate messages can be sent. +// External packages can send messages to this channel, and they will be filtered and forwarded to clients. +// +// Example usage from another package: +// +// server := grpc.NewGrpcServer(50051, nil) +// updateChan := server.GetUpdateChannel() +// +// // Send a block update +// update := &pb.SubscribeUpdate{ +// UpdateOneof: &pb.SubscribeUpdate_Block{ +// Block: &pb.SubscribeUpdateBlock{ +// Slot: 12345, +// Blockhash: "abc123...", +// }, +// }, +// } +// updateChan <- update +func (s *GrpcServer) GetUpdateChannel() chan<- *pb.SubscribeUpdate { + return s.geyserService.GetUpdateChannel() +} + From 2e38c47ac98f1815e53738ed24258748dcd4347e Mon Sep 17 00:00:00 2001 From: dhruvsol Date: Sun, 30 Nov 2025 11:02:33 +0530 Subject: [PATCH 3/6] update to use block chann --- pkg/grpc/geyser_service.go | 152 +++++++++++++++++++++++++++---------- pkg/grpc/grpc.go | 26 +++---- 2 files changed, 123 insertions(+), 55 deletions(-) diff --git a/pkg/grpc/geyser_service.go b/pkg/grpc/geyser_service.go index 30948c4f..52423d42 100644 --- a/pkg/grpc/geyser_service.go +++ b/pkg/grpc/geyser_service.go @@ -6,26 +6,29 @@ import ( "github.com/Overclock-Validator/mithril/pkg/grpc/pb" "google.golang.org/grpc" + + b "github.com/Overclock-Validator/mithril/pkg/block" + "github.com/gagliardetto/solana-go" ) type GeyserService struct { pb.UnimplementedGeyserServer - - // Channel for receiving SubscribeUpdate messages that need to be filtered and sent - updateChan chan *pb.SubscribeUpdate + + // Channel for sending Blocks to client + blockChan chan *b.Block } func NewGeyserService() *GeyserService { return &GeyserService{ - updateChan: make(chan *pb.SubscribeUpdate, 100), + blockChan: make(chan *b.Block, 100), } } -// GetUpdateChannel returns the channel where SubscribeUpdate messages can be sent -// External code can send messages to this channel, and they will be filtered and forwarded -func (s *GeyserService) GetUpdateChannel() chan<- *pb.SubscribeUpdate { - return s.updateChan +// GetBlockChannel returns the channel where Block messages can be sent +// External code can send blocks to this channel, and they will be filtered and forwarded to clients +func (s *GeyserService) GetBlockChannel() chan<- *b.Block { + return s.blockChan } func (s *GeyserService) Ping(ctx context.Context, req *pb.PingRequest) (*pb.PongResponse, error) { @@ -88,34 +91,27 @@ func (s *GeyserService) Subscribe(stream grpc.BidiStreamingServer[pb.SubscribeRe // Handle ping/pong if req.Ping != nil { - filterIDs := s.extractFilterIDs(activeRequest) pong := &pb.SubscribeUpdate{ - Filters: filterIDs, UpdateOneof: &pb.SubscribeUpdate_Pong{ Pong: &pb.SubscribeUpdatePong{ Id: req.Ping.Id, }, }, } - select { - case updateChan <- pong: - case <-ctx.Done(): - return ctx.Err() + if err := s.sendUpdate(pong, activeRequest, updateChan, ctx); err != nil { + return err } continue } activeRequest = req - case update := <-s.updateChan: - if s.shouldSendUpdate(update, activeRequest) { - if activeRequest != nil { - update.Filters = s.extractFilterIDs(activeRequest) - } - select { - case updateChan <- update: - case <-ctx.Done(): - return ctx.Err() + case block := <-s.blockChan: + // Filter block first, then convert if it passes + if s.shouldSendBlock(block, activeRequest) { + update := s.convertBlockToSubscribeUpdate(block) + if err := s.sendUpdate(update, activeRequest, updateChan, ctx); err != nil { + return err } } @@ -140,41 +136,115 @@ func (s *GeyserService) extractFilterIDs(req *pb.SubscribeRequest) []string { return filterIDs } -func (s *GeyserService) shouldSendUpdate(update *pb.SubscribeUpdate, req *pb.SubscribeRequest) bool { - if req == nil { - return true +// sendUpdate sends an update to the client channel with proper error handling +func (s *GeyserService) sendUpdate(update *pb.SubscribeUpdate, req *pb.SubscribeRequest, updateChan chan<- *pb.SubscribeUpdate, ctx context.Context) error { + if req != nil { + update.Filters = s.extractFilterIDs(req) } - - // Always send ping/pong messages - switch update.UpdateOneof.(type) { - case *pb.SubscribeUpdate_Ping, *pb.SubscribeUpdate_Pong: - return true - case *pb.SubscribeUpdate_Block: - return s.matchesBlockFilter(update.GetBlock(), req) - default: - return false + select { + case updateChan <- update: + return nil + case <-ctx.Done(): + return ctx.Err() } } -func (s *GeyserService) matchesBlockFilter(block *pb.SubscribeUpdateBlock, req *pb.SubscribeRequest) bool { +// shouldSendBlock checks if a Block should be sent based on the active request filters +// This filters the block BEFORE converting to SubscribeUpdate for better performance +func (s *GeyserService) shouldSendBlock(block *b.Block, req *pb.SubscribeRequest) bool { + if req == nil { + return true + } + if len(req.Blocks) == 0 { return false } + return s.matchesBlockFilterForBlock(block, req) +} + +// matchesBlockFilterForBlock checks if a Block matches the request filters +func (s *GeyserService) matchesBlockFilterForBlock(block *b.Block, req *pb.SubscribeRequest) bool { for _, filter := range req.Blocks { if len(filter.AccountInclude) > 0 { - accounts := block.GetAccounts() - - for _, account := range accounts { - if slices.Contains(filter.AccountInclude, string(account.Pubkey)) { + // Check if any account in block.UpdatedAccts matches + for _, pubkey := range block.UpdatedAccts { + pubkeyStr := pubkey.String() + if slices.Contains(filter.AccountInclude, pubkeyStr) { return true } } + + // Check EpochUpdatedAccts if available + for _, account := range block.EpochUpdatedAccts { + if account != nil { + pubkeyStr := account.Key.String() + if slices.Contains(filter.AccountInclude, pubkeyStr) { + return true + } + } + } + + // Check ParentEpochUpdatedAccts if available + for _, account := range block.ParentEpochUpdatedAccts { + if account != nil { + pubkeyStr := account.Key.String() + if slices.Contains(filter.AccountInclude, pubkeyStr) { + return true + } + } + } - // TODO build other filters here + // If account_include filter exists but no match found, don't send return false } + + // If no specific filters, match all blocks + return true } return true } + +// convertBlockToSubscribeUpdate converts a Block to SubscribeUpdate with Block update +func (s *GeyserService) convertBlockToSubscribeUpdate(block *b.Block) *pb.SubscribeUpdate { + blockUpdate := &pb.SubscribeUpdateBlock{ + Slot: block.Slot, + Blockhash: solana.Hash(block.Blockhash).String(), + ParentSlot: block.ParentSlot, + ParentBlockhash: solana.Hash(block.LastBlockhash).String(), + ExecutedTransactionCount: uint64(len(block.Transactions)), + UpdatedAccountCount: uint64(len(block.UpdatedAccts)), + EntriesCount: uint64(len(block.Entries)), + } + + // Set block height if available + if block.BlockHeight > 0 { + blockUpdate.BlockHeight = &pb.BlockHeight{ + BlockHeight: block.BlockHeight, + } + } + + // Set block time if available + if block.UnixTimestamp > 0 { + blockUpdate.BlockTime = &pb.UnixTimestamp{ + Timestamp: block.UnixTimestamp, + } + } + + // Convert accounts if available (from UpdatedAccts or EpochUpdatedAccts) + // Note: This is a simplified conversion - you may need to fetch full account data + accounts := make([]*pb.SubscribeUpdateAccountInfo, 0, len(block.UpdatedAccts)) + for _, pubkey := range block.UpdatedAccts { + accounts = append(accounts, &pb.SubscribeUpdateAccountInfo{ + Pubkey: pubkey[:], + }) + } + blockUpdate.Accounts = accounts + + return &pb.SubscribeUpdate{ + UpdateOneof: &pb.SubscribeUpdate_Block{ + Block: blockUpdate, + }, + } +} diff --git a/pkg/grpc/grpc.go b/pkg/grpc/grpc.go index 6035dc9b..700ab222 100644 --- a/pkg/grpc/grpc.go +++ b/pkg/grpc/grpc.go @@ -5,6 +5,7 @@ import ( "log" "net" + b "github.com/Overclock-Validator/mithril/pkg/block" "github.com/Overclock-Validator/mithril/pkg/grpc/pb" "google.golang.org/grpc" ) @@ -40,25 +41,22 @@ func (s *GrpcServer) GracefulStop() { s.server.GracefulStop() } -// GetUpdateChannel returns the channel where SubscribeUpdate messages can be sent. -// External packages can send messages to this channel, and they will be filtered and forwarded to clients. +// GetBlockChannel returns the channel where Block messages can be sent. +// External packages can send blocks to this channel, and they will be filtered and forwarded to clients. // // Example usage from another package: // // server := grpc.NewGrpcServer(50051, nil) -// updateChan := server.GetUpdateChannel() +// blockChan := server.GetBlockChannel() // -// // Send a block update -// update := &pb.SubscribeUpdate{ -// UpdateOneof: &pb.SubscribeUpdate_Block{ -// Block: &pb.SubscribeUpdateBlock{ -// Slot: 12345, -// Blockhash: "abc123...", -// }, -// }, +// // Send a block (will be converted to SubscribeUpdate and filtered) +// block := &block.Block{ +// Slot: 12345, +// Blockhash: [32]byte{...}, +// // ... other fields // } -// updateChan <- update -func (s *GrpcServer) GetUpdateChannel() chan<- *pb.SubscribeUpdate { - return s.geyserService.GetUpdateChannel() +// blockChan <- block +func (s *GrpcServer) GetBlockChannel() chan<- *b.Block { + return s.geyserService.GetBlockChannel() } From 3ee5d7d6fc8c40f5b85dede643cf4edb5230446a Mon Sep 17 00:00:00 2001 From: dhruvsol Date: Thu, 4 Dec 2025 00:04:42 +0530 Subject: [PATCH 4/6] migrated block sender to a routine --- pkg/grpc/geyser_service.go | 37 +++++++++++++++++++++++++------------ 1 file changed, 25 insertions(+), 12 deletions(-) diff --git a/pkg/grpc/geyser_service.go b/pkg/grpc/geyser_service.go index 52423d42..d41674de 100644 --- a/pkg/grpc/geyser_service.go +++ b/pkg/grpc/geyser_service.go @@ -49,6 +49,8 @@ func (s *GeyserService) Subscribe(stream grpc.BidiStreamingServer[pb.SubscribeRe // Channel to signal when we're done done := make(chan error, 1) + // Main loop: process requests and filter updates + var activeRequest *pb.SubscribeRequest // Goroutine to receive SubscribeRequest messages from the client go func() { for { @@ -78,14 +80,32 @@ func (s *GeyserService) Subscribe(stream grpc.BidiStreamingServer[pb.SubscribeRe } }() - // Main loop: process requests and filter updates - var activeRequest *pb.SubscribeRequest + // Goroutine to send blocks to the client + go func() { + for { + select { + case req, ok := <-s.blockChan: + if !ok { + return + } + block := s.convertBlockToSubscribeUpdate(req) + if err := s.sendUpdate(block, activeRequest, updateChan, ctx); err != nil { + done <- err + return + } + case <-ctx.Done(): + return + } + } + }() + + + - for { + for { select { case req, ok := <-requestChan: if !ok { - // Client closed the request stream return nil } @@ -106,14 +126,6 @@ func (s *GeyserService) Subscribe(stream grpc.BidiStreamingServer[pb.SubscribeRe activeRequest = req - case block := <-s.blockChan: - // Filter block first, then convert if it passes - if s.shouldSendBlock(block, activeRequest) { - update := s.convertBlockToSubscribeUpdate(block) - if err := s.sendUpdate(update, activeRequest, updateChan, ctx); err != nil { - return err - } - } case err := <-done: return err @@ -122,6 +134,7 @@ func (s *GeyserService) Subscribe(stream grpc.BidiStreamingServer[pb.SubscribeRe return ctx.Err() } } + } func (s *GeyserService) extractFilterIDs(req *pb.SubscribeRequest) []string { From 7819b5f14be9bfc116b828671254f80ca28b22c7 Mon Sep 17 00:00:00 2001 From: dhruvsol Date: Thu, 4 Dec 2025 00:32:44 +0530 Subject: [PATCH 5/6] added args --- cmd/mithril/node/node.go | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/cmd/mithril/node/node.go b/cmd/mithril/node/node.go index f6a6b013..e3aa1094 100644 --- a/cmd/mithril/node/node.go +++ b/cmd/mithril/node/node.go @@ -88,6 +88,10 @@ var ( borrowedAccountArenaSize uint64 rpcPort int + + // grpc flags + grpcPort int + enableGrpc bool ) func init() { @@ -114,6 +118,8 @@ func init() { Verifier.Flags().BoolVar(&sbpf.UsePool, "use-pool", true, "Disable to allocate fresh slices") Verifier.Flags().StringVar(&snapshotDlPath, "download-snapshot", "", "Path to download snapshot to") Verifier.Flags().IntVar(&rpcPort, "rpc-server-port", 0, "RPC server port. Default off.") + Verifier.Flags().BoolVar(&enableGrpc, "enable-grpc", false, "Enable gRPC server. Default off.") + Verifier.Flags().IntVar(&grpcPort, "grpc-port", 50051, "gRPC server port. Default 50051.") // flags for RPC catchup mode CatchupRpc.Flags().StringVarP(&outputDir, "out", "o", "", "Output path for writing AccountsDB data to") @@ -132,6 +138,8 @@ func init() { CatchupRpc.Flags().StringVar(&blockDir, "blockdir", "/tmp/blocks", "Path containing slot.json files") CatchupRpc.Flags().StringVar(&scratchDir, "scratchdir", "/tmp", "Path for downloads (e.g. snapshots) and other temp state") CatchupRpc.Flags().IntVar(&rpcPort, "rpc-server-port", 0, "RPC server port. Default off.") + CatchupRpc.Flags().BoolVar(&enableGrpc, "enable-grpc", false, "Enable gRPC server. Default off.") + CatchupRpc.Flags().IntVar(&grpcPort, "grpc-port", 50051, "gRPC server port. Default 50051.") // flags for Overcast catchup mode CatchupOvercast.Flags().StringVarP(&outputDir, "out", "o", "", "Output path for writing AccountsDB data to") @@ -151,6 +159,8 @@ func init() { CatchupOvercast.Flags().StringVar(&blockDir, "blockdir", "/tmp/blocks", "Path containing slot.json files") CatchupOvercast.Flags().StringVar(&scratchDir, "scratchdir", "/tmp", "Path for downloads (e.g. snapshots) and other temp state") CatchupOvercast.Flags().IntVar(&rpcPort, "rpc-server-port", 0, "RPC server port. Default off.") + CatchupOvercast.Flags().BoolVar(&enableGrpc, "enable-grpc", false, "Enable gRPC server. Default off.") + CatchupOvercast.Flags().IntVar(&grpcPort, "grpc-port", 50051, "gRPC server port. Default 50051.") } func runVerifier(c *cobra.Command, args []string) { @@ -164,7 +174,6 @@ func runVerifier(c *cobra.Command, args []string) { if !loadFromSnapshot && !loadFromAccountsDb && snapshotDlPath == "" { klog.Fatalf("must specify either to load from a snapshot, or load from an existing AccountsDB, or download a snapshot.") } - var err error var accountsDbDir string var accountsDb *accountsdb.AccountsDb @@ -185,6 +194,7 @@ func runVerifier(c *cobra.Command, args []string) { defer pprof.StopCPUProfile() } + if rpcEndpoint == "" { rpcEndpoint = "https://api.mainnet-beta.solana.com" } From 33371e824cabed84856ea50eead8603f747818d5 Mon Sep 17 00:00:00 2001 From: dhruvsol Date: Thu, 4 Dec 2025 13:39:55 +0530 Subject: [PATCH 6/6] remove old geyser streaming --- cmd/mithril/node/node.go | 43 + pkg/grpc/geyser_service.go | 3 +- pkg/grpc/grpc.go | 2 +- pkg/grpc/grpc_test.go | 2 +- pkg/grpc/pb/geyser.pb.go | 3203 ------------------------------ pkg/grpc/pb/geyser.proto | 279 --- pkg/grpc/pb/geyser_grpc.pb.go | 382 ---- pkg/grpc/pb/solana-storage.pb.go | 1559 --------------- pkg/grpc/pb/solana-storage.proto | 151 -- 9 files changed, 47 insertions(+), 5577 deletions(-) delete mode 100644 pkg/grpc/pb/geyser.pb.go delete mode 100644 pkg/grpc/pb/geyser.proto delete mode 100644 pkg/grpc/pb/geyser_grpc.pb.go delete mode 100644 pkg/grpc/pb/solana-storage.pb.go delete mode 100644 pkg/grpc/pb/solana-storage.proto diff --git a/cmd/mithril/node/node.go b/cmd/mithril/node/node.go index e3aa1094..5735b265 100644 --- a/cmd/mithril/node/node.go +++ b/cmd/mithril/node/node.go @@ -18,6 +18,7 @@ import ( "github.com/Overclock-Validator/mithril/pkg/accountsdb" "github.com/Overclock-Validator/mithril/pkg/arena" + "github.com/Overclock-Validator/mithril/pkg/grpc" "github.com/Overclock-Validator/mithril/pkg/mlog" "github.com/Overclock-Validator/mithril/pkg/replay" "github.com/Overclock-Validator/mithril/pkg/rpcserver" @@ -299,6 +300,19 @@ func runVerifier(c *cobra.Command, args []string) { rpcServer.Start() mlog.Log.Infof("started RPC server on port %d", rpcPort) } + if enableGrpc { + + if grpcPort == 0 || grpcPort > 65535 || grpcPort < 0 { + grpcPort = 50051 + } + + grpcServer := grpc.NewGrpcServer(uint16(grpcPort), nil) + err := grpcServer.Start() + if err != nil { + klog.Fatalf("failed to start gRPC server: %v", err) + } + mlog.Log.Infof("started gRPC server on port %d", grpcPort) + } replay.ReplayBlocks(c.Context(), accountsDb, accountsDbDir, manifest, uint64(startSlot), uint64(endSlot), rpcEndpoint, blockDir, int(txParallelism), false, false, dbgOpts, metricsWriter, rpcServer) mlog.Log.Infof("done replaying, closing DB") @@ -379,6 +393,20 @@ func runRpcCatchup(c *cobra.Command, args []string) { mlog.Log.Infof("started RPC server on port %d", rpcPort) } + if enableGrpc { + + if grpcPort == 0 || grpcPort > 65535 || grpcPort < 0 { + grpcPort = 50051 + } + + grpcServer := grpc.NewGrpcServer(uint16(grpcPort), nil) + err := grpcServer.Start() + if err != nil { + klog.Fatalf("failed to start gRPC server: %v", err) + } + mlog.Log.Infof("started gRPC server on port %d", grpcPort) + } + replay.ReplayBlocks(c.Context(), accountsDb, outputDir, manifest, uint64(startSlot), uint64(endSlot), rpcEndpoint, blockDir, int(txParallelism), true, false, dbgOpts, metricsWriter, rpcServer) mlog.Log.Infof("done replaying, closing DB") accountsDb.CloseDb() @@ -462,6 +490,21 @@ func runOvercastCatchup(c *cobra.Command, args []string) { mlog.Log.Infof("started RPC server on port %d", rpcPort) } + if enableGrpc { + + if grpcPort == 0 || grpcPort > 65535 || grpcPort < 0 { + grpcPort = 50051 + } + + grpcServer := grpc.NewGrpcServer(uint16(grpcPort), nil) + err := grpcServer.Start() + if err != nil { + klog.Fatalf("failed to start gRPC server: %v", err) + } + mlog.Log.Infof("started gRPC server on port %d", grpcPort) + } + + replay.ReplayBlocks(c.Context(), accountsDb, outputDir, manifest, uint64(startSlot), uint64(endSlot), rpcEndpoint, blockDir, int(txParallelism), true, true, dbgOpts, metricsWriter, rpcServer) mlog.Log.Infof("done replaying, closing DB") accountsDb.CloseDb() diff --git a/pkg/grpc/geyser_service.go b/pkg/grpc/geyser_service.go index d41674de..01111847 100644 --- a/pkg/grpc/geyser_service.go +++ b/pkg/grpc/geyser_service.go @@ -4,10 +4,11 @@ import ( "context" "slices" - "github.com/Overclock-Validator/mithril/pkg/grpc/pb" "google.golang.org/grpc" b "github.com/Overclock-Validator/mithril/pkg/block" + pb "github.com/rpcpool/yellowstone-grpc/examples/golang/proto" + "github.com/gagliardetto/solana-go" ) diff --git a/pkg/grpc/grpc.go b/pkg/grpc/grpc.go index 700ab222..4e78c69f 100644 --- a/pkg/grpc/grpc.go +++ b/pkg/grpc/grpc.go @@ -6,7 +6,7 @@ import ( "net" b "github.com/Overclock-Validator/mithril/pkg/block" - "github.com/Overclock-Validator/mithril/pkg/grpc/pb" + pb "github.com/rpcpool/yellowstone-grpc/examples/golang/proto" "google.golang.org/grpc" ) diff --git a/pkg/grpc/grpc_test.go b/pkg/grpc/grpc_test.go index 835c1dd2..03062f71 100644 --- a/pkg/grpc/grpc_test.go +++ b/pkg/grpc/grpc_test.go @@ -6,7 +6,7 @@ import ( "testing" "time" - "github.com/Overclock-Validator/mithril/pkg/grpc/pb" + pb "github.com/rpcpool/yellowstone-grpc/examples/golang/proto" "google.golang.org/grpc" "google.golang.org/grpc/credentials/insecure" ) diff --git a/pkg/grpc/pb/geyser.pb.go b/pkg/grpc/pb/geyser.pb.go deleted file mode 100644 index 1ac569ad..00000000 --- a/pkg/grpc/pb/geyser.pb.go +++ /dev/null @@ -1,3203 +0,0 @@ -// Code generated by protoc-gen-go. DO NOT EDIT. -// versions: -// protoc-gen-go v1.36.10 -// protoc v5.28.0 -// source: geyser.proto - -package pb - -import ( - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" - timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" - unsafe "unsafe" -) - -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) -) - -type CommitmentLevel int32 - -const ( - CommitmentLevel_PROCESSED CommitmentLevel = 0 - CommitmentLevel_CONFIRMED CommitmentLevel = 1 - CommitmentLevel_FINALIZED CommitmentLevel = 2 -) - -// Enum value maps for CommitmentLevel. -var ( - CommitmentLevel_name = map[int32]string{ - 0: "PROCESSED", - 1: "CONFIRMED", - 2: "FINALIZED", - } - CommitmentLevel_value = map[string]int32{ - "PROCESSED": 0, - "CONFIRMED": 1, - "FINALIZED": 2, - } -) - -func (x CommitmentLevel) Enum() *CommitmentLevel { - p := new(CommitmentLevel) - *p = x - return p -} - -func (x CommitmentLevel) String() string { - return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) -} - -func (CommitmentLevel) Descriptor() protoreflect.EnumDescriptor { - return file_geyser_proto_enumTypes[0].Descriptor() -} - -func (CommitmentLevel) Type() protoreflect.EnumType { - return &file_geyser_proto_enumTypes[0] -} - -func (x CommitmentLevel) Number() protoreflect.EnumNumber { - return protoreflect.EnumNumber(x) -} - -// Deprecated: Use CommitmentLevel.Descriptor instead. -func (CommitmentLevel) EnumDescriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{0} -} - -type SlotStatus int32 - -const ( - SlotStatus_SLOT_PROCESSED SlotStatus = 0 - SlotStatus_SLOT_CONFIRMED SlotStatus = 1 - SlotStatus_SLOT_FINALIZED SlotStatus = 2 - SlotStatus_SLOT_FIRST_SHRED_RECEIVED SlotStatus = 3 - SlotStatus_SLOT_COMPLETED SlotStatus = 4 - SlotStatus_SLOT_CREATED_BANK SlotStatus = 5 - SlotStatus_SLOT_DEAD SlotStatus = 6 -) - -// Enum value maps for SlotStatus. -var ( - SlotStatus_name = map[int32]string{ - 0: "SLOT_PROCESSED", - 1: "SLOT_CONFIRMED", - 2: "SLOT_FINALIZED", - 3: "SLOT_FIRST_SHRED_RECEIVED", - 4: "SLOT_COMPLETED", - 5: "SLOT_CREATED_BANK", - 6: "SLOT_DEAD", - } - SlotStatus_value = map[string]int32{ - "SLOT_PROCESSED": 0, - "SLOT_CONFIRMED": 1, - "SLOT_FINALIZED": 2, - "SLOT_FIRST_SHRED_RECEIVED": 3, - "SLOT_COMPLETED": 4, - "SLOT_CREATED_BANK": 5, - "SLOT_DEAD": 6, - } -) - -func (x SlotStatus) Enum() *SlotStatus { - p := new(SlotStatus) - *p = x - return p -} - -func (x SlotStatus) String() string { - return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) -} - -func (SlotStatus) Descriptor() protoreflect.EnumDescriptor { - return file_geyser_proto_enumTypes[1].Descriptor() -} - -func (SlotStatus) Type() protoreflect.EnumType { - return &file_geyser_proto_enumTypes[1] -} - -func (x SlotStatus) Number() protoreflect.EnumNumber { - return protoreflect.EnumNumber(x) -} - -// Deprecated: Use SlotStatus.Descriptor instead. -func (SlotStatus) EnumDescriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{1} -} - -type SubscribeRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Accounts map[string]*SubscribeRequestFilterAccounts `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - Slots map[string]*SubscribeRequestFilterSlots `protobuf:"bytes,2,rep,name=slots,proto3" json:"slots,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - Transactions map[string]*SubscribeRequestFilterTransactions `protobuf:"bytes,3,rep,name=transactions,proto3" json:"transactions,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - TransactionsStatus map[string]*SubscribeRequestFilterTransactions `protobuf:"bytes,10,rep,name=transactions_status,json=transactionsStatus,proto3" json:"transactions_status,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - Blocks map[string]*SubscribeRequestFilterBlocks `protobuf:"bytes,4,rep,name=blocks,proto3" json:"blocks,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - BlocksMeta map[string]*SubscribeRequestFilterBlocksMeta `protobuf:"bytes,5,rep,name=blocks_meta,json=blocksMeta,proto3" json:"blocks_meta,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - Entry map[string]*SubscribeRequestFilterEntry `protobuf:"bytes,8,rep,name=entry,proto3" json:"entry,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - Commitment *CommitmentLevel `protobuf:"varint,6,opt,name=commitment,proto3,enum=geyser.CommitmentLevel,oneof" json:"commitment,omitempty"` - AccountsDataSlice []*SubscribeRequestAccountsDataSlice `protobuf:"bytes,7,rep,name=accounts_data_slice,json=accountsDataSlice,proto3" json:"accounts_data_slice,omitempty"` - Ping *SubscribeRequestPing `protobuf:"bytes,9,opt,name=ping,proto3,oneof" json:"ping,omitempty"` - FromSlot *uint64 `protobuf:"varint,11,opt,name=from_slot,json=fromSlot,proto3,oneof" json:"from_slot,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequest) Reset() { - *x = SubscribeRequest{} - mi := &file_geyser_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequest) ProtoMessage() {} - -func (x *SubscribeRequest) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[0] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequest.ProtoReflect.Descriptor instead. -func (*SubscribeRequest) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{0} -} - -func (x *SubscribeRequest) GetAccounts() map[string]*SubscribeRequestFilterAccounts { - if x != nil { - return x.Accounts - } - return nil -} - -func (x *SubscribeRequest) GetSlots() map[string]*SubscribeRequestFilterSlots { - if x != nil { - return x.Slots - } - return nil -} - -func (x *SubscribeRequest) GetTransactions() map[string]*SubscribeRequestFilterTransactions { - if x != nil { - return x.Transactions - } - return nil -} - -func (x *SubscribeRequest) GetTransactionsStatus() map[string]*SubscribeRequestFilterTransactions { - if x != nil { - return x.TransactionsStatus - } - return nil -} - -func (x *SubscribeRequest) GetBlocks() map[string]*SubscribeRequestFilterBlocks { - if x != nil { - return x.Blocks - } - return nil -} - -func (x *SubscribeRequest) GetBlocksMeta() map[string]*SubscribeRequestFilterBlocksMeta { - if x != nil { - return x.BlocksMeta - } - return nil -} - -func (x *SubscribeRequest) GetEntry() map[string]*SubscribeRequestFilterEntry { - if x != nil { - return x.Entry - } - return nil -} - -func (x *SubscribeRequest) GetCommitment() CommitmentLevel { - if x != nil && x.Commitment != nil { - return *x.Commitment - } - return CommitmentLevel_PROCESSED -} - -func (x *SubscribeRequest) GetAccountsDataSlice() []*SubscribeRequestAccountsDataSlice { - if x != nil { - return x.AccountsDataSlice - } - return nil -} - -func (x *SubscribeRequest) GetPing() *SubscribeRequestPing { - if x != nil { - return x.Ping - } - return nil -} - -func (x *SubscribeRequest) GetFromSlot() uint64 { - if x != nil && x.FromSlot != nil { - return *x.FromSlot - } - return 0 -} - -type SubscribeRequestFilterAccounts struct { - state protoimpl.MessageState `protogen:"open.v1"` - Account []string `protobuf:"bytes,2,rep,name=account,proto3" json:"account,omitempty"` - Owner []string `protobuf:"bytes,3,rep,name=owner,proto3" json:"owner,omitempty"` - Filters []*SubscribeRequestFilterAccountsFilter `protobuf:"bytes,4,rep,name=filters,proto3" json:"filters,omitempty"` - NonemptyTxnSignature *bool `protobuf:"varint,5,opt,name=nonempty_txn_signature,json=nonemptyTxnSignature,proto3,oneof" json:"nonempty_txn_signature,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequestFilterAccounts) Reset() { - *x = SubscribeRequestFilterAccounts{} - mi := &file_geyser_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequestFilterAccounts) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequestFilterAccounts) ProtoMessage() {} - -func (x *SubscribeRequestFilterAccounts) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[1] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequestFilterAccounts.ProtoReflect.Descriptor instead. -func (*SubscribeRequestFilterAccounts) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{1} -} - -func (x *SubscribeRequestFilterAccounts) GetAccount() []string { - if x != nil { - return x.Account - } - return nil -} - -func (x *SubscribeRequestFilterAccounts) GetOwner() []string { - if x != nil { - return x.Owner - } - return nil -} - -func (x *SubscribeRequestFilterAccounts) GetFilters() []*SubscribeRequestFilterAccountsFilter { - if x != nil { - return x.Filters - } - return nil -} - -func (x *SubscribeRequestFilterAccounts) GetNonemptyTxnSignature() bool { - if x != nil && x.NonemptyTxnSignature != nil { - return *x.NonemptyTxnSignature - } - return false -} - -type SubscribeRequestFilterAccountsFilter struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Types that are valid to be assigned to Filter: - // - // *SubscribeRequestFilterAccountsFilter_Memcmp - // *SubscribeRequestFilterAccountsFilter_Datasize - // *SubscribeRequestFilterAccountsFilter_TokenAccountState - // *SubscribeRequestFilterAccountsFilter_Lamports - Filter isSubscribeRequestFilterAccountsFilter_Filter `protobuf_oneof:"filter"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequestFilterAccountsFilter) Reset() { - *x = SubscribeRequestFilterAccountsFilter{} - mi := &file_geyser_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequestFilterAccountsFilter) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequestFilterAccountsFilter) ProtoMessage() {} - -func (x *SubscribeRequestFilterAccountsFilter) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[2] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequestFilterAccountsFilter.ProtoReflect.Descriptor instead. -func (*SubscribeRequestFilterAccountsFilter) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{2} -} - -func (x *SubscribeRequestFilterAccountsFilter) GetFilter() isSubscribeRequestFilterAccountsFilter_Filter { - if x != nil { - return x.Filter - } - return nil -} - -func (x *SubscribeRequestFilterAccountsFilter) GetMemcmp() *SubscribeRequestFilterAccountsFilterMemcmp { - if x != nil { - if x, ok := x.Filter.(*SubscribeRequestFilterAccountsFilter_Memcmp); ok { - return x.Memcmp - } - } - return nil -} - -func (x *SubscribeRequestFilterAccountsFilter) GetDatasize() uint64 { - if x != nil { - if x, ok := x.Filter.(*SubscribeRequestFilterAccountsFilter_Datasize); ok { - return x.Datasize - } - } - return 0 -} - -func (x *SubscribeRequestFilterAccountsFilter) GetTokenAccountState() bool { - if x != nil { - if x, ok := x.Filter.(*SubscribeRequestFilterAccountsFilter_TokenAccountState); ok { - return x.TokenAccountState - } - } - return false -} - -func (x *SubscribeRequestFilterAccountsFilter) GetLamports() *SubscribeRequestFilterAccountsFilterLamports { - if x != nil { - if x, ok := x.Filter.(*SubscribeRequestFilterAccountsFilter_Lamports); ok { - return x.Lamports - } - } - return nil -} - -type isSubscribeRequestFilterAccountsFilter_Filter interface { - isSubscribeRequestFilterAccountsFilter_Filter() -} - -type SubscribeRequestFilterAccountsFilter_Memcmp struct { - Memcmp *SubscribeRequestFilterAccountsFilterMemcmp `protobuf:"bytes,1,opt,name=memcmp,proto3,oneof"` -} - -type SubscribeRequestFilterAccountsFilter_Datasize struct { - Datasize uint64 `protobuf:"varint,2,opt,name=datasize,proto3,oneof"` -} - -type SubscribeRequestFilterAccountsFilter_TokenAccountState struct { - TokenAccountState bool `protobuf:"varint,3,opt,name=token_account_state,json=tokenAccountState,proto3,oneof"` -} - -type SubscribeRequestFilterAccountsFilter_Lamports struct { - Lamports *SubscribeRequestFilterAccountsFilterLamports `protobuf:"bytes,4,opt,name=lamports,proto3,oneof"` -} - -func (*SubscribeRequestFilterAccountsFilter_Memcmp) isSubscribeRequestFilterAccountsFilter_Filter() {} - -func (*SubscribeRequestFilterAccountsFilter_Datasize) isSubscribeRequestFilterAccountsFilter_Filter() { -} - -func (*SubscribeRequestFilterAccountsFilter_TokenAccountState) isSubscribeRequestFilterAccountsFilter_Filter() { -} - -func (*SubscribeRequestFilterAccountsFilter_Lamports) isSubscribeRequestFilterAccountsFilter_Filter() { -} - -type SubscribeRequestFilterAccountsFilterMemcmp struct { - state protoimpl.MessageState `protogen:"open.v1"` - Offset uint64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"` - // Types that are valid to be assigned to Data: - // - // *SubscribeRequestFilterAccountsFilterMemcmp_Bytes - // *SubscribeRequestFilterAccountsFilterMemcmp_Base58 - // *SubscribeRequestFilterAccountsFilterMemcmp_Base64 - Data isSubscribeRequestFilterAccountsFilterMemcmp_Data `protobuf_oneof:"data"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequestFilterAccountsFilterMemcmp) Reset() { - *x = SubscribeRequestFilterAccountsFilterMemcmp{} - mi := &file_geyser_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequestFilterAccountsFilterMemcmp) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequestFilterAccountsFilterMemcmp) ProtoMessage() {} - -func (x *SubscribeRequestFilterAccountsFilterMemcmp) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[3] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequestFilterAccountsFilterMemcmp.ProtoReflect.Descriptor instead. -func (*SubscribeRequestFilterAccountsFilterMemcmp) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{3} -} - -func (x *SubscribeRequestFilterAccountsFilterMemcmp) GetOffset() uint64 { - if x != nil { - return x.Offset - } - return 0 -} - -func (x *SubscribeRequestFilterAccountsFilterMemcmp) GetData() isSubscribeRequestFilterAccountsFilterMemcmp_Data { - if x != nil { - return x.Data - } - return nil -} - -func (x *SubscribeRequestFilterAccountsFilterMemcmp) GetBytes() []byte { - if x != nil { - if x, ok := x.Data.(*SubscribeRequestFilterAccountsFilterMemcmp_Bytes); ok { - return x.Bytes - } - } - return nil -} - -func (x *SubscribeRequestFilterAccountsFilterMemcmp) GetBase58() string { - if x != nil { - if x, ok := x.Data.(*SubscribeRequestFilterAccountsFilterMemcmp_Base58); ok { - return x.Base58 - } - } - return "" -} - -func (x *SubscribeRequestFilterAccountsFilterMemcmp) GetBase64() string { - if x != nil { - if x, ok := x.Data.(*SubscribeRequestFilterAccountsFilterMemcmp_Base64); ok { - return x.Base64 - } - } - return "" -} - -type isSubscribeRequestFilterAccountsFilterMemcmp_Data interface { - isSubscribeRequestFilterAccountsFilterMemcmp_Data() -} - -type SubscribeRequestFilterAccountsFilterMemcmp_Bytes struct { - Bytes []byte `protobuf:"bytes,2,opt,name=bytes,proto3,oneof"` -} - -type SubscribeRequestFilterAccountsFilterMemcmp_Base58 struct { - Base58 string `protobuf:"bytes,3,opt,name=base58,proto3,oneof"` -} - -type SubscribeRequestFilterAccountsFilterMemcmp_Base64 struct { - Base64 string `protobuf:"bytes,4,opt,name=base64,proto3,oneof"` -} - -func (*SubscribeRequestFilterAccountsFilterMemcmp_Bytes) isSubscribeRequestFilterAccountsFilterMemcmp_Data() { -} - -func (*SubscribeRequestFilterAccountsFilterMemcmp_Base58) isSubscribeRequestFilterAccountsFilterMemcmp_Data() { -} - -func (*SubscribeRequestFilterAccountsFilterMemcmp_Base64) isSubscribeRequestFilterAccountsFilterMemcmp_Data() { -} - -type SubscribeRequestFilterAccountsFilterLamports struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Types that are valid to be assigned to Cmp: - // - // *SubscribeRequestFilterAccountsFilterLamports_Eq - // *SubscribeRequestFilterAccountsFilterLamports_Ne - // *SubscribeRequestFilterAccountsFilterLamports_Lt - // *SubscribeRequestFilterAccountsFilterLamports_Gt - Cmp isSubscribeRequestFilterAccountsFilterLamports_Cmp `protobuf_oneof:"cmp"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequestFilterAccountsFilterLamports) Reset() { - *x = SubscribeRequestFilterAccountsFilterLamports{} - mi := &file_geyser_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequestFilterAccountsFilterLamports) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequestFilterAccountsFilterLamports) ProtoMessage() {} - -func (x *SubscribeRequestFilterAccountsFilterLamports) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[4] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequestFilterAccountsFilterLamports.ProtoReflect.Descriptor instead. -func (*SubscribeRequestFilterAccountsFilterLamports) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{4} -} - -func (x *SubscribeRequestFilterAccountsFilterLamports) GetCmp() isSubscribeRequestFilterAccountsFilterLamports_Cmp { - if x != nil { - return x.Cmp - } - return nil -} - -func (x *SubscribeRequestFilterAccountsFilterLamports) GetEq() uint64 { - if x != nil { - if x, ok := x.Cmp.(*SubscribeRequestFilterAccountsFilterLamports_Eq); ok { - return x.Eq - } - } - return 0 -} - -func (x *SubscribeRequestFilterAccountsFilterLamports) GetNe() uint64 { - if x != nil { - if x, ok := x.Cmp.(*SubscribeRequestFilterAccountsFilterLamports_Ne); ok { - return x.Ne - } - } - return 0 -} - -func (x *SubscribeRequestFilterAccountsFilterLamports) GetLt() uint64 { - if x != nil { - if x, ok := x.Cmp.(*SubscribeRequestFilterAccountsFilterLamports_Lt); ok { - return x.Lt - } - } - return 0 -} - -func (x *SubscribeRequestFilterAccountsFilterLamports) GetGt() uint64 { - if x != nil { - if x, ok := x.Cmp.(*SubscribeRequestFilterAccountsFilterLamports_Gt); ok { - return x.Gt - } - } - return 0 -} - -type isSubscribeRequestFilterAccountsFilterLamports_Cmp interface { - isSubscribeRequestFilterAccountsFilterLamports_Cmp() -} - -type SubscribeRequestFilterAccountsFilterLamports_Eq struct { - Eq uint64 `protobuf:"varint,1,opt,name=eq,proto3,oneof"` -} - -type SubscribeRequestFilterAccountsFilterLamports_Ne struct { - Ne uint64 `protobuf:"varint,2,opt,name=ne,proto3,oneof"` -} - -type SubscribeRequestFilterAccountsFilterLamports_Lt struct { - Lt uint64 `protobuf:"varint,3,opt,name=lt,proto3,oneof"` -} - -type SubscribeRequestFilterAccountsFilterLamports_Gt struct { - Gt uint64 `protobuf:"varint,4,opt,name=gt,proto3,oneof"` -} - -func (*SubscribeRequestFilterAccountsFilterLamports_Eq) isSubscribeRequestFilterAccountsFilterLamports_Cmp() { -} - -func (*SubscribeRequestFilterAccountsFilterLamports_Ne) isSubscribeRequestFilterAccountsFilterLamports_Cmp() { -} - -func (*SubscribeRequestFilterAccountsFilterLamports_Lt) isSubscribeRequestFilterAccountsFilterLamports_Cmp() { -} - -func (*SubscribeRequestFilterAccountsFilterLamports_Gt) isSubscribeRequestFilterAccountsFilterLamports_Cmp() { -} - -type SubscribeRequestFilterSlots struct { - state protoimpl.MessageState `protogen:"open.v1"` - FilterByCommitment *bool `protobuf:"varint,1,opt,name=filter_by_commitment,json=filterByCommitment,proto3,oneof" json:"filter_by_commitment,omitempty"` - InterslotUpdates *bool `protobuf:"varint,2,opt,name=interslot_updates,json=interslotUpdates,proto3,oneof" json:"interslot_updates,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequestFilterSlots) Reset() { - *x = SubscribeRequestFilterSlots{} - mi := &file_geyser_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequestFilterSlots) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequestFilterSlots) ProtoMessage() {} - -func (x *SubscribeRequestFilterSlots) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[5] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequestFilterSlots.ProtoReflect.Descriptor instead. -func (*SubscribeRequestFilterSlots) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{5} -} - -func (x *SubscribeRequestFilterSlots) GetFilterByCommitment() bool { - if x != nil && x.FilterByCommitment != nil { - return *x.FilterByCommitment - } - return false -} - -func (x *SubscribeRequestFilterSlots) GetInterslotUpdates() bool { - if x != nil && x.InterslotUpdates != nil { - return *x.InterslotUpdates - } - return false -} - -type SubscribeRequestFilterTransactions struct { - state protoimpl.MessageState `protogen:"open.v1"` - Vote *bool `protobuf:"varint,1,opt,name=vote,proto3,oneof" json:"vote,omitempty"` - Failed *bool `protobuf:"varint,2,opt,name=failed,proto3,oneof" json:"failed,omitempty"` - Signature *string `protobuf:"bytes,5,opt,name=signature,proto3,oneof" json:"signature,omitempty"` - AccountInclude []string `protobuf:"bytes,3,rep,name=account_include,json=accountInclude,proto3" json:"account_include,omitempty"` - AccountExclude []string `protobuf:"bytes,4,rep,name=account_exclude,json=accountExclude,proto3" json:"account_exclude,omitempty"` - AccountRequired []string `protobuf:"bytes,6,rep,name=account_required,json=accountRequired,proto3" json:"account_required,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequestFilterTransactions) Reset() { - *x = SubscribeRequestFilterTransactions{} - mi := &file_geyser_proto_msgTypes[6] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequestFilterTransactions) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequestFilterTransactions) ProtoMessage() {} - -func (x *SubscribeRequestFilterTransactions) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[6] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequestFilterTransactions.ProtoReflect.Descriptor instead. -func (*SubscribeRequestFilterTransactions) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{6} -} - -func (x *SubscribeRequestFilterTransactions) GetVote() bool { - if x != nil && x.Vote != nil { - return *x.Vote - } - return false -} - -func (x *SubscribeRequestFilterTransactions) GetFailed() bool { - if x != nil && x.Failed != nil { - return *x.Failed - } - return false -} - -func (x *SubscribeRequestFilterTransactions) GetSignature() string { - if x != nil && x.Signature != nil { - return *x.Signature - } - return "" -} - -func (x *SubscribeRequestFilterTransactions) GetAccountInclude() []string { - if x != nil { - return x.AccountInclude - } - return nil -} - -func (x *SubscribeRequestFilterTransactions) GetAccountExclude() []string { - if x != nil { - return x.AccountExclude - } - return nil -} - -func (x *SubscribeRequestFilterTransactions) GetAccountRequired() []string { - if x != nil { - return x.AccountRequired - } - return nil -} - -type SubscribeRequestFilterBlocks struct { - state protoimpl.MessageState `protogen:"open.v1"` - AccountInclude []string `protobuf:"bytes,1,rep,name=account_include,json=accountInclude,proto3" json:"account_include,omitempty"` - IncludeTransactions *bool `protobuf:"varint,2,opt,name=include_transactions,json=includeTransactions,proto3,oneof" json:"include_transactions,omitempty"` - IncludeAccounts *bool `protobuf:"varint,3,opt,name=include_accounts,json=includeAccounts,proto3,oneof" json:"include_accounts,omitempty"` - IncludeEntries *bool `protobuf:"varint,4,opt,name=include_entries,json=includeEntries,proto3,oneof" json:"include_entries,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequestFilterBlocks) Reset() { - *x = SubscribeRequestFilterBlocks{} - mi := &file_geyser_proto_msgTypes[7] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequestFilterBlocks) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequestFilterBlocks) ProtoMessage() {} - -func (x *SubscribeRequestFilterBlocks) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[7] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequestFilterBlocks.ProtoReflect.Descriptor instead. -func (*SubscribeRequestFilterBlocks) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{7} -} - -func (x *SubscribeRequestFilterBlocks) GetAccountInclude() []string { - if x != nil { - return x.AccountInclude - } - return nil -} - -func (x *SubscribeRequestFilterBlocks) GetIncludeTransactions() bool { - if x != nil && x.IncludeTransactions != nil { - return *x.IncludeTransactions - } - return false -} - -func (x *SubscribeRequestFilterBlocks) GetIncludeAccounts() bool { - if x != nil && x.IncludeAccounts != nil { - return *x.IncludeAccounts - } - return false -} - -func (x *SubscribeRequestFilterBlocks) GetIncludeEntries() bool { - if x != nil && x.IncludeEntries != nil { - return *x.IncludeEntries - } - return false -} - -type SubscribeRequestFilterBlocksMeta struct { - state protoimpl.MessageState `protogen:"open.v1"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequestFilterBlocksMeta) Reset() { - *x = SubscribeRequestFilterBlocksMeta{} - mi := &file_geyser_proto_msgTypes[8] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequestFilterBlocksMeta) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequestFilterBlocksMeta) ProtoMessage() {} - -func (x *SubscribeRequestFilterBlocksMeta) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[8] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequestFilterBlocksMeta.ProtoReflect.Descriptor instead. -func (*SubscribeRequestFilterBlocksMeta) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{8} -} - -type SubscribeRequestFilterEntry struct { - state protoimpl.MessageState `protogen:"open.v1"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequestFilterEntry) Reset() { - *x = SubscribeRequestFilterEntry{} - mi := &file_geyser_proto_msgTypes[9] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequestFilterEntry) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequestFilterEntry) ProtoMessage() {} - -func (x *SubscribeRequestFilterEntry) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[9] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequestFilterEntry.ProtoReflect.Descriptor instead. -func (*SubscribeRequestFilterEntry) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{9} -} - -type SubscribeRequestAccountsDataSlice struct { - state protoimpl.MessageState `protogen:"open.v1"` - Offset uint64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"` - Length uint64 `protobuf:"varint,2,opt,name=length,proto3" json:"length,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequestAccountsDataSlice) Reset() { - *x = SubscribeRequestAccountsDataSlice{} - mi := &file_geyser_proto_msgTypes[10] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequestAccountsDataSlice) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequestAccountsDataSlice) ProtoMessage() {} - -func (x *SubscribeRequestAccountsDataSlice) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[10] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequestAccountsDataSlice.ProtoReflect.Descriptor instead. -func (*SubscribeRequestAccountsDataSlice) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{10} -} - -func (x *SubscribeRequestAccountsDataSlice) GetOffset() uint64 { - if x != nil { - return x.Offset - } - return 0 -} - -func (x *SubscribeRequestAccountsDataSlice) GetLength() uint64 { - if x != nil { - return x.Length - } - return 0 -} - -type SubscribeRequestPing struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeRequestPing) Reset() { - *x = SubscribeRequestPing{} - mi := &file_geyser_proto_msgTypes[11] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeRequestPing) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeRequestPing) ProtoMessage() {} - -func (x *SubscribeRequestPing) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[11] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeRequestPing.ProtoReflect.Descriptor instead. -func (*SubscribeRequestPing) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{11} -} - -func (x *SubscribeRequestPing) GetId() int32 { - if x != nil { - return x.Id - } - return 0 -} - -type SubscribeUpdate struct { - state protoimpl.MessageState `protogen:"open.v1"` - Filters []string `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"` - // Types that are valid to be assigned to UpdateOneof: - // - // *SubscribeUpdate_Account - // *SubscribeUpdate_Slot - // *SubscribeUpdate_Transaction - // *SubscribeUpdate_TransactionStatus - // *SubscribeUpdate_Block - // *SubscribeUpdate_Ping - // *SubscribeUpdate_Pong - // *SubscribeUpdate_BlockMeta - // *SubscribeUpdate_Entry - UpdateOneof isSubscribeUpdate_UpdateOneof `protobuf_oneof:"update_oneof"` - CreatedAt *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdate) Reset() { - *x = SubscribeUpdate{} - mi := &file_geyser_proto_msgTypes[12] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdate) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdate) ProtoMessage() {} - -func (x *SubscribeUpdate) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[12] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdate.ProtoReflect.Descriptor instead. -func (*SubscribeUpdate) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{12} -} - -func (x *SubscribeUpdate) GetFilters() []string { - if x != nil { - return x.Filters - } - return nil -} - -func (x *SubscribeUpdate) GetUpdateOneof() isSubscribeUpdate_UpdateOneof { - if x != nil { - return x.UpdateOneof - } - return nil -} - -func (x *SubscribeUpdate) GetAccount() *SubscribeUpdateAccount { - if x != nil { - if x, ok := x.UpdateOneof.(*SubscribeUpdate_Account); ok { - return x.Account - } - } - return nil -} - -func (x *SubscribeUpdate) GetSlot() *SubscribeUpdateSlot { - if x != nil { - if x, ok := x.UpdateOneof.(*SubscribeUpdate_Slot); ok { - return x.Slot - } - } - return nil -} - -func (x *SubscribeUpdate) GetTransaction() *SubscribeUpdateTransaction { - if x != nil { - if x, ok := x.UpdateOneof.(*SubscribeUpdate_Transaction); ok { - return x.Transaction - } - } - return nil -} - -func (x *SubscribeUpdate) GetTransactionStatus() *SubscribeUpdateTransactionStatus { - if x != nil { - if x, ok := x.UpdateOneof.(*SubscribeUpdate_TransactionStatus); ok { - return x.TransactionStatus - } - } - return nil -} - -func (x *SubscribeUpdate) GetBlock() *SubscribeUpdateBlock { - if x != nil { - if x, ok := x.UpdateOneof.(*SubscribeUpdate_Block); ok { - return x.Block - } - } - return nil -} - -func (x *SubscribeUpdate) GetPing() *SubscribeUpdatePing { - if x != nil { - if x, ok := x.UpdateOneof.(*SubscribeUpdate_Ping); ok { - return x.Ping - } - } - return nil -} - -func (x *SubscribeUpdate) GetPong() *SubscribeUpdatePong { - if x != nil { - if x, ok := x.UpdateOneof.(*SubscribeUpdate_Pong); ok { - return x.Pong - } - } - return nil -} - -func (x *SubscribeUpdate) GetBlockMeta() *SubscribeUpdateBlockMeta { - if x != nil { - if x, ok := x.UpdateOneof.(*SubscribeUpdate_BlockMeta); ok { - return x.BlockMeta - } - } - return nil -} - -func (x *SubscribeUpdate) GetEntry() *SubscribeUpdateEntry { - if x != nil { - if x, ok := x.UpdateOneof.(*SubscribeUpdate_Entry); ok { - return x.Entry - } - } - return nil -} - -func (x *SubscribeUpdate) GetCreatedAt() *timestamppb.Timestamp { - if x != nil { - return x.CreatedAt - } - return nil -} - -type isSubscribeUpdate_UpdateOneof interface { - isSubscribeUpdate_UpdateOneof() -} - -type SubscribeUpdate_Account struct { - Account *SubscribeUpdateAccount `protobuf:"bytes,2,opt,name=account,proto3,oneof"` -} - -type SubscribeUpdate_Slot struct { - Slot *SubscribeUpdateSlot `protobuf:"bytes,3,opt,name=slot,proto3,oneof"` -} - -type SubscribeUpdate_Transaction struct { - Transaction *SubscribeUpdateTransaction `protobuf:"bytes,4,opt,name=transaction,proto3,oneof"` -} - -type SubscribeUpdate_TransactionStatus struct { - TransactionStatus *SubscribeUpdateTransactionStatus `protobuf:"bytes,10,opt,name=transaction_status,json=transactionStatus,proto3,oneof"` -} - -type SubscribeUpdate_Block struct { - Block *SubscribeUpdateBlock `protobuf:"bytes,5,opt,name=block,proto3,oneof"` -} - -type SubscribeUpdate_Ping struct { - Ping *SubscribeUpdatePing `protobuf:"bytes,6,opt,name=ping,proto3,oneof"` -} - -type SubscribeUpdate_Pong struct { - Pong *SubscribeUpdatePong `protobuf:"bytes,9,opt,name=pong,proto3,oneof"` -} - -type SubscribeUpdate_BlockMeta struct { - BlockMeta *SubscribeUpdateBlockMeta `protobuf:"bytes,7,opt,name=block_meta,json=blockMeta,proto3,oneof"` -} - -type SubscribeUpdate_Entry struct { - Entry *SubscribeUpdateEntry `protobuf:"bytes,8,opt,name=entry,proto3,oneof"` -} - -func (*SubscribeUpdate_Account) isSubscribeUpdate_UpdateOneof() {} - -func (*SubscribeUpdate_Slot) isSubscribeUpdate_UpdateOneof() {} - -func (*SubscribeUpdate_Transaction) isSubscribeUpdate_UpdateOneof() {} - -func (*SubscribeUpdate_TransactionStatus) isSubscribeUpdate_UpdateOneof() {} - -func (*SubscribeUpdate_Block) isSubscribeUpdate_UpdateOneof() {} - -func (*SubscribeUpdate_Ping) isSubscribeUpdate_UpdateOneof() {} - -func (*SubscribeUpdate_Pong) isSubscribeUpdate_UpdateOneof() {} - -func (*SubscribeUpdate_BlockMeta) isSubscribeUpdate_UpdateOneof() {} - -func (*SubscribeUpdate_Entry) isSubscribeUpdate_UpdateOneof() {} - -type SubscribeUpdateAccount struct { - state protoimpl.MessageState `protogen:"open.v1"` - Account *SubscribeUpdateAccountInfo `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"` - Slot uint64 `protobuf:"varint,2,opt,name=slot,proto3" json:"slot,omitempty"` - IsStartup bool `protobuf:"varint,3,opt,name=is_startup,json=isStartup,proto3" json:"is_startup,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdateAccount) Reset() { - *x = SubscribeUpdateAccount{} - mi := &file_geyser_proto_msgTypes[13] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdateAccount) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdateAccount) ProtoMessage() {} - -func (x *SubscribeUpdateAccount) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[13] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdateAccount.ProtoReflect.Descriptor instead. -func (*SubscribeUpdateAccount) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{13} -} - -func (x *SubscribeUpdateAccount) GetAccount() *SubscribeUpdateAccountInfo { - if x != nil { - return x.Account - } - return nil -} - -func (x *SubscribeUpdateAccount) GetSlot() uint64 { - if x != nil { - return x.Slot - } - return 0 -} - -func (x *SubscribeUpdateAccount) GetIsStartup() bool { - if x != nil { - return x.IsStartup - } - return false -} - -type SubscribeUpdateAccountInfo struct { - state protoimpl.MessageState `protogen:"open.v1"` - Pubkey []byte `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"` - Lamports uint64 `protobuf:"varint,2,opt,name=lamports,proto3" json:"lamports,omitempty"` - Owner []byte `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"` - Executable bool `protobuf:"varint,4,opt,name=executable,proto3" json:"executable,omitempty"` - RentEpoch uint64 `protobuf:"varint,5,opt,name=rent_epoch,json=rentEpoch,proto3" json:"rent_epoch,omitempty"` - Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"` - WriteVersion uint64 `protobuf:"varint,7,opt,name=write_version,json=writeVersion,proto3" json:"write_version,omitempty"` - TxnSignature []byte `protobuf:"bytes,8,opt,name=txn_signature,json=txnSignature,proto3,oneof" json:"txn_signature,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdateAccountInfo) Reset() { - *x = SubscribeUpdateAccountInfo{} - mi := &file_geyser_proto_msgTypes[14] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdateAccountInfo) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdateAccountInfo) ProtoMessage() {} - -func (x *SubscribeUpdateAccountInfo) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[14] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdateAccountInfo.ProtoReflect.Descriptor instead. -func (*SubscribeUpdateAccountInfo) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{14} -} - -func (x *SubscribeUpdateAccountInfo) GetPubkey() []byte { - if x != nil { - return x.Pubkey - } - return nil -} - -func (x *SubscribeUpdateAccountInfo) GetLamports() uint64 { - if x != nil { - return x.Lamports - } - return 0 -} - -func (x *SubscribeUpdateAccountInfo) GetOwner() []byte { - if x != nil { - return x.Owner - } - return nil -} - -func (x *SubscribeUpdateAccountInfo) GetExecutable() bool { - if x != nil { - return x.Executable - } - return false -} - -func (x *SubscribeUpdateAccountInfo) GetRentEpoch() uint64 { - if x != nil { - return x.RentEpoch - } - return 0 -} - -func (x *SubscribeUpdateAccountInfo) GetData() []byte { - if x != nil { - return x.Data - } - return nil -} - -func (x *SubscribeUpdateAccountInfo) GetWriteVersion() uint64 { - if x != nil { - return x.WriteVersion - } - return 0 -} - -func (x *SubscribeUpdateAccountInfo) GetTxnSignature() []byte { - if x != nil { - return x.TxnSignature - } - return nil -} - -type SubscribeUpdateSlot struct { - state protoimpl.MessageState `protogen:"open.v1"` - Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` - Parent *uint64 `protobuf:"varint,2,opt,name=parent,proto3,oneof" json:"parent,omitempty"` - Status SlotStatus `protobuf:"varint,3,opt,name=status,proto3,enum=geyser.SlotStatus" json:"status,omitempty"` - DeadError *string `protobuf:"bytes,4,opt,name=dead_error,json=deadError,proto3,oneof" json:"dead_error,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdateSlot) Reset() { - *x = SubscribeUpdateSlot{} - mi := &file_geyser_proto_msgTypes[15] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdateSlot) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdateSlot) ProtoMessage() {} - -func (x *SubscribeUpdateSlot) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[15] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdateSlot.ProtoReflect.Descriptor instead. -func (*SubscribeUpdateSlot) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{15} -} - -func (x *SubscribeUpdateSlot) GetSlot() uint64 { - if x != nil { - return x.Slot - } - return 0 -} - -func (x *SubscribeUpdateSlot) GetParent() uint64 { - if x != nil && x.Parent != nil { - return *x.Parent - } - return 0 -} - -func (x *SubscribeUpdateSlot) GetStatus() SlotStatus { - if x != nil { - return x.Status - } - return SlotStatus_SLOT_PROCESSED -} - -func (x *SubscribeUpdateSlot) GetDeadError() string { - if x != nil && x.DeadError != nil { - return *x.DeadError - } - return "" -} - -type SubscribeUpdateTransaction struct { - state protoimpl.MessageState `protogen:"open.v1"` - Transaction *SubscribeUpdateTransactionInfo `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"` - Slot uint64 `protobuf:"varint,2,opt,name=slot,proto3" json:"slot,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdateTransaction) Reset() { - *x = SubscribeUpdateTransaction{} - mi := &file_geyser_proto_msgTypes[16] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdateTransaction) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdateTransaction) ProtoMessage() {} - -func (x *SubscribeUpdateTransaction) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[16] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdateTransaction.ProtoReflect.Descriptor instead. -func (*SubscribeUpdateTransaction) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{16} -} - -func (x *SubscribeUpdateTransaction) GetTransaction() *SubscribeUpdateTransactionInfo { - if x != nil { - return x.Transaction - } - return nil -} - -func (x *SubscribeUpdateTransaction) GetSlot() uint64 { - if x != nil { - return x.Slot - } - return 0 -} - -type SubscribeUpdateTransactionInfo struct { - state protoimpl.MessageState `protogen:"open.v1"` - Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"` - IsVote bool `protobuf:"varint,2,opt,name=is_vote,json=isVote,proto3" json:"is_vote,omitempty"` - Transaction *Transaction `protobuf:"bytes,3,opt,name=transaction,proto3" json:"transaction,omitempty"` - Meta *TransactionStatusMeta `protobuf:"bytes,4,opt,name=meta,proto3" json:"meta,omitempty"` - Index uint64 `protobuf:"varint,5,opt,name=index,proto3" json:"index,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdateTransactionInfo) Reset() { - *x = SubscribeUpdateTransactionInfo{} - mi := &file_geyser_proto_msgTypes[17] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdateTransactionInfo) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdateTransactionInfo) ProtoMessage() {} - -func (x *SubscribeUpdateTransactionInfo) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[17] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdateTransactionInfo.ProtoReflect.Descriptor instead. -func (*SubscribeUpdateTransactionInfo) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{17} -} - -func (x *SubscribeUpdateTransactionInfo) GetSignature() []byte { - if x != nil { - return x.Signature - } - return nil -} - -func (x *SubscribeUpdateTransactionInfo) GetIsVote() bool { - if x != nil { - return x.IsVote - } - return false -} - -func (x *SubscribeUpdateTransactionInfo) GetTransaction() *Transaction { - if x != nil { - return x.Transaction - } - return nil -} - -func (x *SubscribeUpdateTransactionInfo) GetMeta() *TransactionStatusMeta { - if x != nil { - return x.Meta - } - return nil -} - -func (x *SubscribeUpdateTransactionInfo) GetIndex() uint64 { - if x != nil { - return x.Index - } - return 0 -} - -type SubscribeUpdateTransactionStatus struct { - state protoimpl.MessageState `protogen:"open.v1"` - Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` - Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"` - IsVote bool `protobuf:"varint,3,opt,name=is_vote,json=isVote,proto3" json:"is_vote,omitempty"` - Index uint64 `protobuf:"varint,4,opt,name=index,proto3" json:"index,omitempty"` - Err *TransactionError `protobuf:"bytes,5,opt,name=err,proto3" json:"err,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdateTransactionStatus) Reset() { - *x = SubscribeUpdateTransactionStatus{} - mi := &file_geyser_proto_msgTypes[18] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdateTransactionStatus) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdateTransactionStatus) ProtoMessage() {} - -func (x *SubscribeUpdateTransactionStatus) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[18] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdateTransactionStatus.ProtoReflect.Descriptor instead. -func (*SubscribeUpdateTransactionStatus) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{18} -} - -func (x *SubscribeUpdateTransactionStatus) GetSlot() uint64 { - if x != nil { - return x.Slot - } - return 0 -} - -func (x *SubscribeUpdateTransactionStatus) GetSignature() []byte { - if x != nil { - return x.Signature - } - return nil -} - -func (x *SubscribeUpdateTransactionStatus) GetIsVote() bool { - if x != nil { - return x.IsVote - } - return false -} - -func (x *SubscribeUpdateTransactionStatus) GetIndex() uint64 { - if x != nil { - return x.Index - } - return 0 -} - -func (x *SubscribeUpdateTransactionStatus) GetErr() *TransactionError { - if x != nil { - return x.Err - } - return nil -} - -type SubscribeUpdateBlock struct { - state protoimpl.MessageState `protogen:"open.v1"` - Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` - Blockhash string `protobuf:"bytes,2,opt,name=blockhash,proto3" json:"blockhash,omitempty"` - Rewards *Rewards `protobuf:"bytes,3,opt,name=rewards,proto3" json:"rewards,omitempty"` - BlockTime *UnixTimestamp `protobuf:"bytes,4,opt,name=block_time,json=blockTime,proto3" json:"block_time,omitempty"` - BlockHeight *BlockHeight `protobuf:"bytes,5,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` - ParentSlot uint64 `protobuf:"varint,7,opt,name=parent_slot,json=parentSlot,proto3" json:"parent_slot,omitempty"` - ParentBlockhash string `protobuf:"bytes,8,opt,name=parent_blockhash,json=parentBlockhash,proto3" json:"parent_blockhash,omitempty"` - ExecutedTransactionCount uint64 `protobuf:"varint,9,opt,name=executed_transaction_count,json=executedTransactionCount,proto3" json:"executed_transaction_count,omitempty"` - Transactions []*SubscribeUpdateTransactionInfo `protobuf:"bytes,6,rep,name=transactions,proto3" json:"transactions,omitempty"` - UpdatedAccountCount uint64 `protobuf:"varint,10,opt,name=updated_account_count,json=updatedAccountCount,proto3" json:"updated_account_count,omitempty"` - Accounts []*SubscribeUpdateAccountInfo `protobuf:"bytes,11,rep,name=accounts,proto3" json:"accounts,omitempty"` - EntriesCount uint64 `protobuf:"varint,12,opt,name=entries_count,json=entriesCount,proto3" json:"entries_count,omitempty"` - Entries []*SubscribeUpdateEntry `protobuf:"bytes,13,rep,name=entries,proto3" json:"entries,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdateBlock) Reset() { - *x = SubscribeUpdateBlock{} - mi := &file_geyser_proto_msgTypes[19] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdateBlock) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdateBlock) ProtoMessage() {} - -func (x *SubscribeUpdateBlock) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[19] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdateBlock.ProtoReflect.Descriptor instead. -func (*SubscribeUpdateBlock) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{19} -} - -func (x *SubscribeUpdateBlock) GetSlot() uint64 { - if x != nil { - return x.Slot - } - return 0 -} - -func (x *SubscribeUpdateBlock) GetBlockhash() string { - if x != nil { - return x.Blockhash - } - return "" -} - -func (x *SubscribeUpdateBlock) GetRewards() *Rewards { - if x != nil { - return x.Rewards - } - return nil -} - -func (x *SubscribeUpdateBlock) GetBlockTime() *UnixTimestamp { - if x != nil { - return x.BlockTime - } - return nil -} - -func (x *SubscribeUpdateBlock) GetBlockHeight() *BlockHeight { - if x != nil { - return x.BlockHeight - } - return nil -} - -func (x *SubscribeUpdateBlock) GetParentSlot() uint64 { - if x != nil { - return x.ParentSlot - } - return 0 -} - -func (x *SubscribeUpdateBlock) GetParentBlockhash() string { - if x != nil { - return x.ParentBlockhash - } - return "" -} - -func (x *SubscribeUpdateBlock) GetExecutedTransactionCount() uint64 { - if x != nil { - return x.ExecutedTransactionCount - } - return 0 -} - -func (x *SubscribeUpdateBlock) GetTransactions() []*SubscribeUpdateTransactionInfo { - if x != nil { - return x.Transactions - } - return nil -} - -func (x *SubscribeUpdateBlock) GetUpdatedAccountCount() uint64 { - if x != nil { - return x.UpdatedAccountCount - } - return 0 -} - -func (x *SubscribeUpdateBlock) GetAccounts() []*SubscribeUpdateAccountInfo { - if x != nil { - return x.Accounts - } - return nil -} - -func (x *SubscribeUpdateBlock) GetEntriesCount() uint64 { - if x != nil { - return x.EntriesCount - } - return 0 -} - -func (x *SubscribeUpdateBlock) GetEntries() []*SubscribeUpdateEntry { - if x != nil { - return x.Entries - } - return nil -} - -type SubscribeUpdateBlockMeta struct { - state protoimpl.MessageState `protogen:"open.v1"` - Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` - Blockhash string `protobuf:"bytes,2,opt,name=blockhash,proto3" json:"blockhash,omitempty"` - Rewards *Rewards `protobuf:"bytes,3,opt,name=rewards,proto3" json:"rewards,omitempty"` - BlockTime *UnixTimestamp `protobuf:"bytes,4,opt,name=block_time,json=blockTime,proto3" json:"block_time,omitempty"` - BlockHeight *BlockHeight `protobuf:"bytes,5,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` - ParentSlot uint64 `protobuf:"varint,6,opt,name=parent_slot,json=parentSlot,proto3" json:"parent_slot,omitempty"` - ParentBlockhash string `protobuf:"bytes,7,opt,name=parent_blockhash,json=parentBlockhash,proto3" json:"parent_blockhash,omitempty"` - ExecutedTransactionCount uint64 `protobuf:"varint,8,opt,name=executed_transaction_count,json=executedTransactionCount,proto3" json:"executed_transaction_count,omitempty"` - EntriesCount uint64 `protobuf:"varint,9,opt,name=entries_count,json=entriesCount,proto3" json:"entries_count,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdateBlockMeta) Reset() { - *x = SubscribeUpdateBlockMeta{} - mi := &file_geyser_proto_msgTypes[20] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdateBlockMeta) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdateBlockMeta) ProtoMessage() {} - -func (x *SubscribeUpdateBlockMeta) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[20] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdateBlockMeta.ProtoReflect.Descriptor instead. -func (*SubscribeUpdateBlockMeta) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{20} -} - -func (x *SubscribeUpdateBlockMeta) GetSlot() uint64 { - if x != nil { - return x.Slot - } - return 0 -} - -func (x *SubscribeUpdateBlockMeta) GetBlockhash() string { - if x != nil { - return x.Blockhash - } - return "" -} - -func (x *SubscribeUpdateBlockMeta) GetRewards() *Rewards { - if x != nil { - return x.Rewards - } - return nil -} - -func (x *SubscribeUpdateBlockMeta) GetBlockTime() *UnixTimestamp { - if x != nil { - return x.BlockTime - } - return nil -} - -func (x *SubscribeUpdateBlockMeta) GetBlockHeight() *BlockHeight { - if x != nil { - return x.BlockHeight - } - return nil -} - -func (x *SubscribeUpdateBlockMeta) GetParentSlot() uint64 { - if x != nil { - return x.ParentSlot - } - return 0 -} - -func (x *SubscribeUpdateBlockMeta) GetParentBlockhash() string { - if x != nil { - return x.ParentBlockhash - } - return "" -} - -func (x *SubscribeUpdateBlockMeta) GetExecutedTransactionCount() uint64 { - if x != nil { - return x.ExecutedTransactionCount - } - return 0 -} - -func (x *SubscribeUpdateBlockMeta) GetEntriesCount() uint64 { - if x != nil { - return x.EntriesCount - } - return 0 -} - -type SubscribeUpdateEntry struct { - state protoimpl.MessageState `protogen:"open.v1"` - Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` - Index uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` - NumHashes uint64 `protobuf:"varint,3,opt,name=num_hashes,json=numHashes,proto3" json:"num_hashes,omitempty"` - Hash []byte `protobuf:"bytes,4,opt,name=hash,proto3" json:"hash,omitempty"` - ExecutedTransactionCount uint64 `protobuf:"varint,5,opt,name=executed_transaction_count,json=executedTransactionCount,proto3" json:"executed_transaction_count,omitempty"` - StartingTransactionIndex uint64 `protobuf:"varint,6,opt,name=starting_transaction_index,json=startingTransactionIndex,proto3" json:"starting_transaction_index,omitempty"` // added in v1.18, for solana 1.17 value is always 0 - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdateEntry) Reset() { - *x = SubscribeUpdateEntry{} - mi := &file_geyser_proto_msgTypes[21] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdateEntry) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdateEntry) ProtoMessage() {} - -func (x *SubscribeUpdateEntry) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[21] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdateEntry.ProtoReflect.Descriptor instead. -func (*SubscribeUpdateEntry) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{21} -} - -func (x *SubscribeUpdateEntry) GetSlot() uint64 { - if x != nil { - return x.Slot - } - return 0 -} - -func (x *SubscribeUpdateEntry) GetIndex() uint64 { - if x != nil { - return x.Index - } - return 0 -} - -func (x *SubscribeUpdateEntry) GetNumHashes() uint64 { - if x != nil { - return x.NumHashes - } - return 0 -} - -func (x *SubscribeUpdateEntry) GetHash() []byte { - if x != nil { - return x.Hash - } - return nil -} - -func (x *SubscribeUpdateEntry) GetExecutedTransactionCount() uint64 { - if x != nil { - return x.ExecutedTransactionCount - } - return 0 -} - -func (x *SubscribeUpdateEntry) GetStartingTransactionIndex() uint64 { - if x != nil { - return x.StartingTransactionIndex - } - return 0 -} - -type SubscribeUpdatePing struct { - state protoimpl.MessageState `protogen:"open.v1"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdatePing) Reset() { - *x = SubscribeUpdatePing{} - mi := &file_geyser_proto_msgTypes[22] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdatePing) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdatePing) ProtoMessage() {} - -func (x *SubscribeUpdatePing) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[22] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdatePing.ProtoReflect.Descriptor instead. -func (*SubscribeUpdatePing) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{22} -} - -type SubscribeUpdatePong struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeUpdatePong) Reset() { - *x = SubscribeUpdatePong{} - mi := &file_geyser_proto_msgTypes[23] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeUpdatePong) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeUpdatePong) ProtoMessage() {} - -func (x *SubscribeUpdatePong) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[23] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeUpdatePong.ProtoReflect.Descriptor instead. -func (*SubscribeUpdatePong) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{23} -} - -func (x *SubscribeUpdatePong) GetId() int32 { - if x != nil { - return x.Id - } - return 0 -} - -type SubscribeReplayInfoRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeReplayInfoRequest) Reset() { - *x = SubscribeReplayInfoRequest{} - mi := &file_geyser_proto_msgTypes[24] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeReplayInfoRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeReplayInfoRequest) ProtoMessage() {} - -func (x *SubscribeReplayInfoRequest) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[24] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeReplayInfoRequest.ProtoReflect.Descriptor instead. -func (*SubscribeReplayInfoRequest) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{24} -} - -type SubscribeReplayInfoResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - FirstAvailable *uint64 `protobuf:"varint,1,opt,name=first_available,json=firstAvailable,proto3,oneof" json:"first_available,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SubscribeReplayInfoResponse) Reset() { - *x = SubscribeReplayInfoResponse{} - mi := &file_geyser_proto_msgTypes[25] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SubscribeReplayInfoResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SubscribeReplayInfoResponse) ProtoMessage() {} - -func (x *SubscribeReplayInfoResponse) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[25] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use SubscribeReplayInfoResponse.ProtoReflect.Descriptor instead. -func (*SubscribeReplayInfoResponse) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{25} -} - -func (x *SubscribeReplayInfoResponse) GetFirstAvailable() uint64 { - if x != nil && x.FirstAvailable != nil { - return *x.FirstAvailable - } - return 0 -} - -type PingRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Count int32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *PingRequest) Reset() { - *x = PingRequest{} - mi := &file_geyser_proto_msgTypes[26] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *PingRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*PingRequest) ProtoMessage() {} - -func (x *PingRequest) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[26] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use PingRequest.ProtoReflect.Descriptor instead. -func (*PingRequest) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{26} -} - -func (x *PingRequest) GetCount() int32 { - if x != nil { - return x.Count - } - return 0 -} - -type PongResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Count int32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *PongResponse) Reset() { - *x = PongResponse{} - mi := &file_geyser_proto_msgTypes[27] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *PongResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*PongResponse) ProtoMessage() {} - -func (x *PongResponse) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[27] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use PongResponse.ProtoReflect.Descriptor instead. -func (*PongResponse) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{27} -} - -func (x *PongResponse) GetCount() int32 { - if x != nil { - return x.Count - } - return 0 -} - -type GetLatestBlockhashRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Commitment *CommitmentLevel `protobuf:"varint,1,opt,name=commitment,proto3,enum=geyser.CommitmentLevel,oneof" json:"commitment,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetLatestBlockhashRequest) Reset() { - *x = GetLatestBlockhashRequest{} - mi := &file_geyser_proto_msgTypes[28] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetLatestBlockhashRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetLatestBlockhashRequest) ProtoMessage() {} - -func (x *GetLatestBlockhashRequest) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[28] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetLatestBlockhashRequest.ProtoReflect.Descriptor instead. -func (*GetLatestBlockhashRequest) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{28} -} - -func (x *GetLatestBlockhashRequest) GetCommitment() CommitmentLevel { - if x != nil && x.Commitment != nil { - return *x.Commitment - } - return CommitmentLevel_PROCESSED -} - -type GetLatestBlockhashResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` - Blockhash string `protobuf:"bytes,2,opt,name=blockhash,proto3" json:"blockhash,omitempty"` - LastValidBlockHeight uint64 `protobuf:"varint,3,opt,name=last_valid_block_height,json=lastValidBlockHeight,proto3" json:"last_valid_block_height,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetLatestBlockhashResponse) Reset() { - *x = GetLatestBlockhashResponse{} - mi := &file_geyser_proto_msgTypes[29] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetLatestBlockhashResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetLatestBlockhashResponse) ProtoMessage() {} - -func (x *GetLatestBlockhashResponse) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[29] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetLatestBlockhashResponse.ProtoReflect.Descriptor instead. -func (*GetLatestBlockhashResponse) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{29} -} - -func (x *GetLatestBlockhashResponse) GetSlot() uint64 { - if x != nil { - return x.Slot - } - return 0 -} - -func (x *GetLatestBlockhashResponse) GetBlockhash() string { - if x != nil { - return x.Blockhash - } - return "" -} - -func (x *GetLatestBlockhashResponse) GetLastValidBlockHeight() uint64 { - if x != nil { - return x.LastValidBlockHeight - } - return 0 -} - -type GetBlockHeightRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Commitment *CommitmentLevel `protobuf:"varint,1,opt,name=commitment,proto3,enum=geyser.CommitmentLevel,oneof" json:"commitment,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetBlockHeightRequest) Reset() { - *x = GetBlockHeightRequest{} - mi := &file_geyser_proto_msgTypes[30] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetBlockHeightRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetBlockHeightRequest) ProtoMessage() {} - -func (x *GetBlockHeightRequest) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[30] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetBlockHeightRequest.ProtoReflect.Descriptor instead. -func (*GetBlockHeightRequest) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{30} -} - -func (x *GetBlockHeightRequest) GetCommitment() CommitmentLevel { - if x != nil && x.Commitment != nil { - return *x.Commitment - } - return CommitmentLevel_PROCESSED -} - -type GetBlockHeightResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - BlockHeight uint64 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetBlockHeightResponse) Reset() { - *x = GetBlockHeightResponse{} - mi := &file_geyser_proto_msgTypes[31] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetBlockHeightResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetBlockHeightResponse) ProtoMessage() {} - -func (x *GetBlockHeightResponse) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[31] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetBlockHeightResponse.ProtoReflect.Descriptor instead. -func (*GetBlockHeightResponse) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{31} -} - -func (x *GetBlockHeightResponse) GetBlockHeight() uint64 { - if x != nil { - return x.BlockHeight - } - return 0 -} - -type GetSlotRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Commitment *CommitmentLevel `protobuf:"varint,1,opt,name=commitment,proto3,enum=geyser.CommitmentLevel,oneof" json:"commitment,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetSlotRequest) Reset() { - *x = GetSlotRequest{} - mi := &file_geyser_proto_msgTypes[32] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetSlotRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetSlotRequest) ProtoMessage() {} - -func (x *GetSlotRequest) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[32] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetSlotRequest.ProtoReflect.Descriptor instead. -func (*GetSlotRequest) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{32} -} - -func (x *GetSlotRequest) GetCommitment() CommitmentLevel { - if x != nil && x.Commitment != nil { - return *x.Commitment - } - return CommitmentLevel_PROCESSED -} - -type GetSlotResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetSlotResponse) Reset() { - *x = GetSlotResponse{} - mi := &file_geyser_proto_msgTypes[33] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetSlotResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetSlotResponse) ProtoMessage() {} - -func (x *GetSlotResponse) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[33] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetSlotResponse.ProtoReflect.Descriptor instead. -func (*GetSlotResponse) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{33} -} - -func (x *GetSlotResponse) GetSlot() uint64 { - if x != nil { - return x.Slot - } - return 0 -} - -type GetVersionRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetVersionRequest) Reset() { - *x = GetVersionRequest{} - mi := &file_geyser_proto_msgTypes[34] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetVersionRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetVersionRequest) ProtoMessage() {} - -func (x *GetVersionRequest) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[34] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetVersionRequest.ProtoReflect.Descriptor instead. -func (*GetVersionRequest) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{34} -} - -type GetVersionResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetVersionResponse) Reset() { - *x = GetVersionResponse{} - mi := &file_geyser_proto_msgTypes[35] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetVersionResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetVersionResponse) ProtoMessage() {} - -func (x *GetVersionResponse) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[35] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetVersionResponse.ProtoReflect.Descriptor instead. -func (*GetVersionResponse) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{35} -} - -func (x *GetVersionResponse) GetVersion() string { - if x != nil { - return x.Version - } - return "" -} - -type IsBlockhashValidRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Blockhash string `protobuf:"bytes,1,opt,name=blockhash,proto3" json:"blockhash,omitempty"` - Commitment *CommitmentLevel `protobuf:"varint,2,opt,name=commitment,proto3,enum=geyser.CommitmentLevel,oneof" json:"commitment,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *IsBlockhashValidRequest) Reset() { - *x = IsBlockhashValidRequest{} - mi := &file_geyser_proto_msgTypes[36] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *IsBlockhashValidRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*IsBlockhashValidRequest) ProtoMessage() {} - -func (x *IsBlockhashValidRequest) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[36] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use IsBlockhashValidRequest.ProtoReflect.Descriptor instead. -func (*IsBlockhashValidRequest) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{36} -} - -func (x *IsBlockhashValidRequest) GetBlockhash() string { - if x != nil { - return x.Blockhash - } - return "" -} - -func (x *IsBlockhashValidRequest) GetCommitment() CommitmentLevel { - if x != nil && x.Commitment != nil { - return *x.Commitment - } - return CommitmentLevel_PROCESSED -} - -type IsBlockhashValidResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` - Valid bool `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *IsBlockhashValidResponse) Reset() { - *x = IsBlockhashValidResponse{} - mi := &file_geyser_proto_msgTypes[37] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *IsBlockhashValidResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*IsBlockhashValidResponse) ProtoMessage() {} - -func (x *IsBlockhashValidResponse) ProtoReflect() protoreflect.Message { - mi := &file_geyser_proto_msgTypes[37] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use IsBlockhashValidResponse.ProtoReflect.Descriptor instead. -func (*IsBlockhashValidResponse) Descriptor() ([]byte, []int) { - return file_geyser_proto_rawDescGZIP(), []int{37} -} - -func (x *IsBlockhashValidResponse) GetSlot() uint64 { - if x != nil { - return x.Slot - } - return 0 -} - -func (x *IsBlockhashValidResponse) GetValid() bool { - if x != nil { - return x.Valid - } - return false -} - -var File_geyser_proto protoreflect.FileDescriptor - -const file_geyser_proto_rawDesc = "" + - "\n" + - "\fgeyser.proto\x12\x06geyser\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x14solana-storage.proto\"\xed\v\n" + - "\x10SubscribeRequest\x12B\n" + - "\baccounts\x18\x01 \x03(\v2&.geyser.SubscribeRequest.AccountsEntryR\baccounts\x129\n" + - "\x05slots\x18\x02 \x03(\v2#.geyser.SubscribeRequest.SlotsEntryR\x05slots\x12N\n" + - "\ftransactions\x18\x03 \x03(\v2*.geyser.SubscribeRequest.TransactionsEntryR\ftransactions\x12a\n" + - "\x13transactions_status\x18\n" + - " \x03(\v20.geyser.SubscribeRequest.TransactionsStatusEntryR\x12transactionsStatus\x12<\n" + - "\x06blocks\x18\x04 \x03(\v2$.geyser.SubscribeRequest.BlocksEntryR\x06blocks\x12I\n" + - "\vblocks_meta\x18\x05 \x03(\v2(.geyser.SubscribeRequest.BlocksMetaEntryR\n" + - "blocksMeta\x129\n" + - "\x05entry\x18\b \x03(\v2#.geyser.SubscribeRequest.EntryEntryR\x05entry\x12<\n" + - "\n" + - "commitment\x18\x06 \x01(\x0e2\x17.geyser.CommitmentLevelH\x00R\n" + - "commitment\x88\x01\x01\x12Y\n" + - "\x13accounts_data_slice\x18\a \x03(\v2).geyser.SubscribeRequestAccountsDataSliceR\x11accountsDataSlice\x125\n" + - "\x04ping\x18\t \x01(\v2\x1c.geyser.SubscribeRequestPingH\x01R\x04ping\x88\x01\x01\x12 \n" + - "\tfrom_slot\x18\v \x01(\x04H\x02R\bfromSlot\x88\x01\x01\x1ac\n" + - "\rAccountsEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12<\n" + - "\x05value\x18\x02 \x01(\v2&.geyser.SubscribeRequestFilterAccountsR\x05value:\x028\x01\x1a]\n" + - "\n" + - "SlotsEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x129\n" + - "\x05value\x18\x02 \x01(\v2#.geyser.SubscribeRequestFilterSlotsR\x05value:\x028\x01\x1ak\n" + - "\x11TransactionsEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12@\n" + - "\x05value\x18\x02 \x01(\v2*.geyser.SubscribeRequestFilterTransactionsR\x05value:\x028\x01\x1aq\n" + - "\x17TransactionsStatusEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12@\n" + - "\x05value\x18\x02 \x01(\v2*.geyser.SubscribeRequestFilterTransactionsR\x05value:\x028\x01\x1a_\n" + - "\vBlocksEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12:\n" + - "\x05value\x18\x02 \x01(\v2$.geyser.SubscribeRequestFilterBlocksR\x05value:\x028\x01\x1ag\n" + - "\x0fBlocksMetaEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12>\n" + - "\x05value\x18\x02 \x01(\v2(.geyser.SubscribeRequestFilterBlocksMetaR\x05value:\x028\x01\x1a]\n" + - "\n" + - "EntryEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x129\n" + - "\x05value\x18\x02 \x01(\v2#.geyser.SubscribeRequestFilterEntryR\x05value:\x028\x01B\r\n" + - "\v_commitmentB\a\n" + - "\x05_pingB\f\n" + - "\n" + - "_from_slot\"\xee\x01\n" + - "\x1eSubscribeRequestFilterAccounts\x12\x18\n" + - "\aaccount\x18\x02 \x03(\tR\aaccount\x12\x14\n" + - "\x05owner\x18\x03 \x03(\tR\x05owner\x12F\n" + - "\afilters\x18\x04 \x03(\v2,.geyser.SubscribeRequestFilterAccountsFilterR\afilters\x129\n" + - "\x16nonempty_txn_signature\x18\x05 \x01(\bH\x00R\x14nonemptyTxnSignature\x88\x01\x01B\x19\n" + - "\x17_nonempty_txn_signature\"\xa2\x02\n" + - "$SubscribeRequestFilterAccountsFilter\x12L\n" + - "\x06memcmp\x18\x01 \x01(\v22.geyser.SubscribeRequestFilterAccountsFilterMemcmpH\x00R\x06memcmp\x12\x1c\n" + - "\bdatasize\x18\x02 \x01(\x04H\x00R\bdatasize\x120\n" + - "\x13token_account_state\x18\x03 \x01(\bH\x00R\x11tokenAccountState\x12R\n" + - "\blamports\x18\x04 \x01(\v24.geyser.SubscribeRequestFilterAccountsFilterLamportsH\x00R\blamportsB\b\n" + - "\x06filter\"\x98\x01\n" + - "*SubscribeRequestFilterAccountsFilterMemcmp\x12\x16\n" + - "\x06offset\x18\x01 \x01(\x04R\x06offset\x12\x16\n" + - "\x05bytes\x18\x02 \x01(\fH\x00R\x05bytes\x12\x18\n" + - "\x06base58\x18\x03 \x01(\tH\x00R\x06base58\x12\x18\n" + - "\x06base64\x18\x04 \x01(\tH\x00R\x06base64B\x06\n" + - "\x04data\"}\n" + - ",SubscribeRequestFilterAccountsFilterLamports\x12\x10\n" + - "\x02eq\x18\x01 \x01(\x04H\x00R\x02eq\x12\x10\n" + - "\x02ne\x18\x02 \x01(\x04H\x00R\x02ne\x12\x10\n" + - "\x02lt\x18\x03 \x01(\x04H\x00R\x02lt\x12\x10\n" + - "\x02gt\x18\x04 \x01(\x04H\x00R\x02gtB\x05\n" + - "\x03cmp\"\xb5\x01\n" + - "\x1bSubscribeRequestFilterSlots\x125\n" + - "\x14filter_by_commitment\x18\x01 \x01(\bH\x00R\x12filterByCommitment\x88\x01\x01\x120\n" + - "\x11interslot_updates\x18\x02 \x01(\bH\x01R\x10interslotUpdates\x88\x01\x01B\x17\n" + - "\x15_filter_by_commitmentB\x14\n" + - "\x12_interslot_updates\"\x9c\x02\n" + - "\"SubscribeRequestFilterTransactions\x12\x17\n" + - "\x04vote\x18\x01 \x01(\bH\x00R\x04vote\x88\x01\x01\x12\x1b\n" + - "\x06failed\x18\x02 \x01(\bH\x01R\x06failed\x88\x01\x01\x12!\n" + - "\tsignature\x18\x05 \x01(\tH\x02R\tsignature\x88\x01\x01\x12'\n" + - "\x0faccount_include\x18\x03 \x03(\tR\x0eaccountInclude\x12'\n" + - "\x0faccount_exclude\x18\x04 \x03(\tR\x0eaccountExclude\x12)\n" + - "\x10account_required\x18\x06 \x03(\tR\x0faccountRequiredB\a\n" + - "\x05_voteB\t\n" + - "\a_failedB\f\n" + - "\n" + - "_signature\"\x9f\x02\n" + - "\x1cSubscribeRequestFilterBlocks\x12'\n" + - "\x0faccount_include\x18\x01 \x03(\tR\x0eaccountInclude\x126\n" + - "\x14include_transactions\x18\x02 \x01(\bH\x00R\x13includeTransactions\x88\x01\x01\x12.\n" + - "\x10include_accounts\x18\x03 \x01(\bH\x01R\x0fincludeAccounts\x88\x01\x01\x12,\n" + - "\x0finclude_entries\x18\x04 \x01(\bH\x02R\x0eincludeEntries\x88\x01\x01B\x17\n" + - "\x15_include_transactionsB\x13\n" + - "\x11_include_accountsB\x12\n" + - "\x10_include_entries\"\"\n" + - " SubscribeRequestFilterBlocksMeta\"\x1d\n" + - "\x1bSubscribeRequestFilterEntry\"S\n" + - "!SubscribeRequestAccountsDataSlice\x12\x16\n" + - "\x06offset\x18\x01 \x01(\x04R\x06offset\x12\x16\n" + - "\x06length\x18\x02 \x01(\x04R\x06length\"&\n" + - "\x14SubscribeRequestPing\x12\x0e\n" + - "\x02id\x18\x01 \x01(\x05R\x02id\"\x9d\x05\n" + - "\x0fSubscribeUpdate\x12\x18\n" + - "\afilters\x18\x01 \x03(\tR\afilters\x12:\n" + - "\aaccount\x18\x02 \x01(\v2\x1e.geyser.SubscribeUpdateAccountH\x00R\aaccount\x121\n" + - "\x04slot\x18\x03 \x01(\v2\x1b.geyser.SubscribeUpdateSlotH\x00R\x04slot\x12F\n" + - "\vtransaction\x18\x04 \x01(\v2\".geyser.SubscribeUpdateTransactionH\x00R\vtransaction\x12Y\n" + - "\x12transaction_status\x18\n" + - " \x01(\v2(.geyser.SubscribeUpdateTransactionStatusH\x00R\x11transactionStatus\x124\n" + - "\x05block\x18\x05 \x01(\v2\x1c.geyser.SubscribeUpdateBlockH\x00R\x05block\x121\n" + - "\x04ping\x18\x06 \x01(\v2\x1b.geyser.SubscribeUpdatePingH\x00R\x04ping\x121\n" + - "\x04pong\x18\t \x01(\v2\x1b.geyser.SubscribeUpdatePongH\x00R\x04pong\x12A\n" + - "\n" + - "block_meta\x18\a \x01(\v2 .geyser.SubscribeUpdateBlockMetaH\x00R\tblockMeta\x124\n" + - "\x05entry\x18\b \x01(\v2\x1c.geyser.SubscribeUpdateEntryH\x00R\x05entry\x129\n" + - "\n" + - "created_at\x18\v \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAtB\x0e\n" + - "\fupdate_oneof\"\x89\x01\n" + - "\x16SubscribeUpdateAccount\x12<\n" + - "\aaccount\x18\x01 \x01(\v2\".geyser.SubscribeUpdateAccountInfoR\aaccount\x12\x12\n" + - "\x04slot\x18\x02 \x01(\x04R\x04slot\x12\x1d\n" + - "\n" + - "is_startup\x18\x03 \x01(\bR\tisStartup\"\x9a\x02\n" + - "\x1aSubscribeUpdateAccountInfo\x12\x16\n" + - "\x06pubkey\x18\x01 \x01(\fR\x06pubkey\x12\x1a\n" + - "\blamports\x18\x02 \x01(\x04R\blamports\x12\x14\n" + - "\x05owner\x18\x03 \x01(\fR\x05owner\x12\x1e\n" + - "\n" + - "executable\x18\x04 \x01(\bR\n" + - "executable\x12\x1d\n" + - "\n" + - "rent_epoch\x18\x05 \x01(\x04R\trentEpoch\x12\x12\n" + - "\x04data\x18\x06 \x01(\fR\x04data\x12#\n" + - "\rwrite_version\x18\a \x01(\x04R\fwriteVersion\x12(\n" + - "\rtxn_signature\x18\b \x01(\fH\x00R\ftxnSignature\x88\x01\x01B\x10\n" + - "\x0e_txn_signature\"\xb0\x01\n" + - "\x13SubscribeUpdateSlot\x12\x12\n" + - "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x1b\n" + - "\x06parent\x18\x02 \x01(\x04H\x00R\x06parent\x88\x01\x01\x12*\n" + - "\x06status\x18\x03 \x01(\x0e2\x12.geyser.SlotStatusR\x06status\x12\"\n" + - "\n" + - "dead_error\x18\x04 \x01(\tH\x01R\tdeadError\x88\x01\x01B\t\n" + - "\a_parentB\r\n" + - "\v_dead_error\"z\n" + - "\x1aSubscribeUpdateTransaction\x12H\n" + - "\vtransaction\x18\x01 \x01(\v2&.geyser.SubscribeUpdateTransactionInfoR\vtransaction\x12\x12\n" + - "\x04slot\x18\x02 \x01(\x04R\x04slot\"\x85\x02\n" + - "\x1eSubscribeUpdateTransactionInfo\x12\x1c\n" + - "\tsignature\x18\x01 \x01(\fR\tsignature\x12\x17\n" + - "\ais_vote\x18\x02 \x01(\bR\x06isVote\x12L\n" + - "\vtransaction\x18\x03 \x01(\v2*.solana.storage.ConfirmedBlock.TransactionR\vtransaction\x12H\n" + - "\x04meta\x18\x04 \x01(\v24.solana.storage.ConfirmedBlock.TransactionStatusMetaR\x04meta\x12\x14\n" + - "\x05index\x18\x05 \x01(\x04R\x05index\"\xc6\x01\n" + - " SubscribeUpdateTransactionStatus\x12\x12\n" + - "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x1c\n" + - "\tsignature\x18\x02 \x01(\fR\tsignature\x12\x17\n" + - "\ais_vote\x18\x03 \x01(\bR\x06isVote\x12\x14\n" + - "\x05index\x18\x04 \x01(\x04R\x05index\x12A\n" + - "\x03err\x18\x05 \x01(\v2/.solana.storage.ConfirmedBlock.TransactionErrorR\x03err\"\xcd\x05\n" + - "\x14SubscribeUpdateBlock\x12\x12\n" + - "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x1c\n" + - "\tblockhash\x18\x02 \x01(\tR\tblockhash\x12@\n" + - "\arewards\x18\x03 \x01(\v2&.solana.storage.ConfirmedBlock.RewardsR\arewards\x12K\n" + - "\n" + - "block_time\x18\x04 \x01(\v2,.solana.storage.ConfirmedBlock.UnixTimestampR\tblockTime\x12M\n" + - "\fblock_height\x18\x05 \x01(\v2*.solana.storage.ConfirmedBlock.BlockHeightR\vblockHeight\x12\x1f\n" + - "\vparent_slot\x18\a \x01(\x04R\n" + - "parentSlot\x12)\n" + - "\x10parent_blockhash\x18\b \x01(\tR\x0fparentBlockhash\x12<\n" + - "\x1aexecuted_transaction_count\x18\t \x01(\x04R\x18executedTransactionCount\x12J\n" + - "\ftransactions\x18\x06 \x03(\v2&.geyser.SubscribeUpdateTransactionInfoR\ftransactions\x122\n" + - "\x15updated_account_count\x18\n" + - " \x01(\x04R\x13updatedAccountCount\x12>\n" + - "\baccounts\x18\v \x03(\v2\".geyser.SubscribeUpdateAccountInfoR\baccounts\x12#\n" + - "\rentries_count\x18\f \x01(\x04R\fentriesCount\x126\n" + - "\aentries\x18\r \x03(\v2\x1c.geyser.SubscribeUpdateEntryR\aentries\"\xd9\x03\n" + - "\x18SubscribeUpdateBlockMeta\x12\x12\n" + - "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x1c\n" + - "\tblockhash\x18\x02 \x01(\tR\tblockhash\x12@\n" + - "\arewards\x18\x03 \x01(\v2&.solana.storage.ConfirmedBlock.RewardsR\arewards\x12K\n" + - "\n" + - "block_time\x18\x04 \x01(\v2,.solana.storage.ConfirmedBlock.UnixTimestampR\tblockTime\x12M\n" + - "\fblock_height\x18\x05 \x01(\v2*.solana.storage.ConfirmedBlock.BlockHeightR\vblockHeight\x12\x1f\n" + - "\vparent_slot\x18\x06 \x01(\x04R\n" + - "parentSlot\x12)\n" + - "\x10parent_blockhash\x18\a \x01(\tR\x0fparentBlockhash\x12<\n" + - "\x1aexecuted_transaction_count\x18\b \x01(\x04R\x18executedTransactionCount\x12#\n" + - "\rentries_count\x18\t \x01(\x04R\fentriesCount\"\xef\x01\n" + - "\x14SubscribeUpdateEntry\x12\x12\n" + - "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x14\n" + - "\x05index\x18\x02 \x01(\x04R\x05index\x12\x1d\n" + - "\n" + - "num_hashes\x18\x03 \x01(\x04R\tnumHashes\x12\x12\n" + - "\x04hash\x18\x04 \x01(\fR\x04hash\x12<\n" + - "\x1aexecuted_transaction_count\x18\x05 \x01(\x04R\x18executedTransactionCount\x12<\n" + - "\x1astarting_transaction_index\x18\x06 \x01(\x04R\x18startingTransactionIndex\"\x15\n" + - "\x13SubscribeUpdatePing\"%\n" + - "\x13SubscribeUpdatePong\x12\x0e\n" + - "\x02id\x18\x01 \x01(\x05R\x02id\"\x1c\n" + - "\x1aSubscribeReplayInfoRequest\"_\n" + - "\x1bSubscribeReplayInfoResponse\x12,\n" + - "\x0ffirst_available\x18\x01 \x01(\x04H\x00R\x0efirstAvailable\x88\x01\x01B\x12\n" + - "\x10_first_available\"#\n" + - "\vPingRequest\x12\x14\n" + - "\x05count\x18\x01 \x01(\x05R\x05count\"$\n" + - "\fPongResponse\x12\x14\n" + - "\x05count\x18\x01 \x01(\x05R\x05count\"h\n" + - "\x19GetLatestBlockhashRequest\x12<\n" + - "\n" + - "commitment\x18\x01 \x01(\x0e2\x17.geyser.CommitmentLevelH\x00R\n" + - "commitment\x88\x01\x01B\r\n" + - "\v_commitment\"\x85\x01\n" + - "\x1aGetLatestBlockhashResponse\x12\x12\n" + - "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x1c\n" + - "\tblockhash\x18\x02 \x01(\tR\tblockhash\x125\n" + - "\x17last_valid_block_height\x18\x03 \x01(\x04R\x14lastValidBlockHeight\"d\n" + - "\x15GetBlockHeightRequest\x12<\n" + - "\n" + - "commitment\x18\x01 \x01(\x0e2\x17.geyser.CommitmentLevelH\x00R\n" + - "commitment\x88\x01\x01B\r\n" + - "\v_commitment\";\n" + - "\x16GetBlockHeightResponse\x12!\n" + - "\fblock_height\x18\x01 \x01(\x04R\vblockHeight\"]\n" + - "\x0eGetSlotRequest\x12<\n" + - "\n" + - "commitment\x18\x01 \x01(\x0e2\x17.geyser.CommitmentLevelH\x00R\n" + - "commitment\x88\x01\x01B\r\n" + - "\v_commitment\"%\n" + - "\x0fGetSlotResponse\x12\x12\n" + - "\x04slot\x18\x01 \x01(\x04R\x04slot\"\x13\n" + - "\x11GetVersionRequest\".\n" + - "\x12GetVersionResponse\x12\x18\n" + - "\aversion\x18\x01 \x01(\tR\aversion\"\x84\x01\n" + - "\x17IsBlockhashValidRequest\x12\x1c\n" + - "\tblockhash\x18\x01 \x01(\tR\tblockhash\x12<\n" + - "\n" + - "commitment\x18\x02 \x01(\x0e2\x17.geyser.CommitmentLevelH\x00R\n" + - "commitment\x88\x01\x01B\r\n" + - "\v_commitment\"D\n" + - "\x18IsBlockhashValidResponse\x12\x12\n" + - "\x04slot\x18\x01 \x01(\x04R\x04slot\x12\x14\n" + - "\x05valid\x18\x02 \x01(\bR\x05valid*>\n" + - "\x0fCommitmentLevel\x12\r\n" + - "\tPROCESSED\x10\x00\x12\r\n" + - "\tCONFIRMED\x10\x01\x12\r\n" + - "\tFINALIZED\x10\x02*\xa1\x01\n" + - "\n" + - "SlotStatus\x12\x12\n" + - "\x0eSLOT_PROCESSED\x10\x00\x12\x12\n" + - "\x0eSLOT_CONFIRMED\x10\x01\x12\x12\n" + - "\x0eSLOT_FINALIZED\x10\x02\x12\x1d\n" + - "\x19SLOT_FIRST_SHRED_RECEIVED\x10\x03\x12\x12\n" + - "\x0eSLOT_COMPLETED\x10\x04\x12\x15\n" + - "\x11SLOT_CREATED_BANK\x10\x05\x12\r\n" + - "\tSLOT_DEAD\x10\x062\xf5\x04\n" + - "\x06Geyser\x12D\n" + - "\tSubscribe\x12\x18.geyser.SubscribeRequest\x1a\x17.geyser.SubscribeUpdate\"\x00(\x010\x01\x12`\n" + - "\x13SubscribeReplayInfo\x12\".geyser.SubscribeReplayInfoRequest\x1a#.geyser.SubscribeReplayInfoResponse\"\x00\x123\n" + - "\x04Ping\x12\x13.geyser.PingRequest\x1a\x14.geyser.PongResponse\"\x00\x12]\n" + - "\x12GetLatestBlockhash\x12!.geyser.GetLatestBlockhashRequest\x1a\".geyser.GetLatestBlockhashResponse\"\x00\x12Q\n" + - "\x0eGetBlockHeight\x12\x1d.geyser.GetBlockHeightRequest\x1a\x1e.geyser.GetBlockHeightResponse\"\x00\x12<\n" + - "\aGetSlot\x12\x16.geyser.GetSlotRequest\x1a\x17.geyser.GetSlotResponse\"\x00\x12W\n" + - "\x10IsBlockhashValid\x12\x1f.geyser.IsBlockhashValidRequest\x1a .geyser.IsBlockhashValidResponse\"\x00\x12E\n" + - "\n" + - "GetVersion\x12\x19.geyser.GetVersionRequest\x1a\x1a.geyser.GetVersionResponse\"\x00B4Z2github.com/Overclock-Validator/mithril/pkg/grpc/pbP\x01b\x06proto3" - -var ( - file_geyser_proto_rawDescOnce sync.Once - file_geyser_proto_rawDescData []byte -) - -func file_geyser_proto_rawDescGZIP() []byte { - file_geyser_proto_rawDescOnce.Do(func() { - file_geyser_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_geyser_proto_rawDesc), len(file_geyser_proto_rawDesc))) - }) - return file_geyser_proto_rawDescData -} - -var file_geyser_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_geyser_proto_msgTypes = make([]protoimpl.MessageInfo, 45) -var file_geyser_proto_goTypes = []any{ - (CommitmentLevel)(0), // 0: geyser.CommitmentLevel - (SlotStatus)(0), // 1: geyser.SlotStatus - (*SubscribeRequest)(nil), // 2: geyser.SubscribeRequest - (*SubscribeRequestFilterAccounts)(nil), // 3: geyser.SubscribeRequestFilterAccounts - (*SubscribeRequestFilterAccountsFilter)(nil), // 4: geyser.SubscribeRequestFilterAccountsFilter - (*SubscribeRequestFilterAccountsFilterMemcmp)(nil), // 5: geyser.SubscribeRequestFilterAccountsFilterMemcmp - (*SubscribeRequestFilterAccountsFilterLamports)(nil), // 6: geyser.SubscribeRequestFilterAccountsFilterLamports - (*SubscribeRequestFilterSlots)(nil), // 7: geyser.SubscribeRequestFilterSlots - (*SubscribeRequestFilterTransactions)(nil), // 8: geyser.SubscribeRequestFilterTransactions - (*SubscribeRequestFilterBlocks)(nil), // 9: geyser.SubscribeRequestFilterBlocks - (*SubscribeRequestFilterBlocksMeta)(nil), // 10: geyser.SubscribeRequestFilterBlocksMeta - (*SubscribeRequestFilterEntry)(nil), // 11: geyser.SubscribeRequestFilterEntry - (*SubscribeRequestAccountsDataSlice)(nil), // 12: geyser.SubscribeRequestAccountsDataSlice - (*SubscribeRequestPing)(nil), // 13: geyser.SubscribeRequestPing - (*SubscribeUpdate)(nil), // 14: geyser.SubscribeUpdate - (*SubscribeUpdateAccount)(nil), // 15: geyser.SubscribeUpdateAccount - (*SubscribeUpdateAccountInfo)(nil), // 16: geyser.SubscribeUpdateAccountInfo - (*SubscribeUpdateSlot)(nil), // 17: geyser.SubscribeUpdateSlot - (*SubscribeUpdateTransaction)(nil), // 18: geyser.SubscribeUpdateTransaction - (*SubscribeUpdateTransactionInfo)(nil), // 19: geyser.SubscribeUpdateTransactionInfo - (*SubscribeUpdateTransactionStatus)(nil), // 20: geyser.SubscribeUpdateTransactionStatus - (*SubscribeUpdateBlock)(nil), // 21: geyser.SubscribeUpdateBlock - (*SubscribeUpdateBlockMeta)(nil), // 22: geyser.SubscribeUpdateBlockMeta - (*SubscribeUpdateEntry)(nil), // 23: geyser.SubscribeUpdateEntry - (*SubscribeUpdatePing)(nil), // 24: geyser.SubscribeUpdatePing - (*SubscribeUpdatePong)(nil), // 25: geyser.SubscribeUpdatePong - (*SubscribeReplayInfoRequest)(nil), // 26: geyser.SubscribeReplayInfoRequest - (*SubscribeReplayInfoResponse)(nil), // 27: geyser.SubscribeReplayInfoResponse - (*PingRequest)(nil), // 28: geyser.PingRequest - (*PongResponse)(nil), // 29: geyser.PongResponse - (*GetLatestBlockhashRequest)(nil), // 30: geyser.GetLatestBlockhashRequest - (*GetLatestBlockhashResponse)(nil), // 31: geyser.GetLatestBlockhashResponse - (*GetBlockHeightRequest)(nil), // 32: geyser.GetBlockHeightRequest - (*GetBlockHeightResponse)(nil), // 33: geyser.GetBlockHeightResponse - (*GetSlotRequest)(nil), // 34: geyser.GetSlotRequest - (*GetSlotResponse)(nil), // 35: geyser.GetSlotResponse - (*GetVersionRequest)(nil), // 36: geyser.GetVersionRequest - (*GetVersionResponse)(nil), // 37: geyser.GetVersionResponse - (*IsBlockhashValidRequest)(nil), // 38: geyser.IsBlockhashValidRequest - (*IsBlockhashValidResponse)(nil), // 39: geyser.IsBlockhashValidResponse - nil, // 40: geyser.SubscribeRequest.AccountsEntry - nil, // 41: geyser.SubscribeRequest.SlotsEntry - nil, // 42: geyser.SubscribeRequest.TransactionsEntry - nil, // 43: geyser.SubscribeRequest.TransactionsStatusEntry - nil, // 44: geyser.SubscribeRequest.BlocksEntry - nil, // 45: geyser.SubscribeRequest.BlocksMetaEntry - nil, // 46: geyser.SubscribeRequest.EntryEntry - (*timestamppb.Timestamp)(nil), // 47: google.protobuf.Timestamp - (*Transaction)(nil), // 48: solana.storage.ConfirmedBlock.Transaction - (*TransactionStatusMeta)(nil), // 49: solana.storage.ConfirmedBlock.TransactionStatusMeta - (*TransactionError)(nil), // 50: solana.storage.ConfirmedBlock.TransactionError - (*Rewards)(nil), // 51: solana.storage.ConfirmedBlock.Rewards - (*UnixTimestamp)(nil), // 52: solana.storage.ConfirmedBlock.UnixTimestamp - (*BlockHeight)(nil), // 53: solana.storage.ConfirmedBlock.BlockHeight -} -var file_geyser_proto_depIdxs = []int32{ - 40, // 0: geyser.SubscribeRequest.accounts:type_name -> geyser.SubscribeRequest.AccountsEntry - 41, // 1: geyser.SubscribeRequest.slots:type_name -> geyser.SubscribeRequest.SlotsEntry - 42, // 2: geyser.SubscribeRequest.transactions:type_name -> geyser.SubscribeRequest.TransactionsEntry - 43, // 3: geyser.SubscribeRequest.transactions_status:type_name -> geyser.SubscribeRequest.TransactionsStatusEntry - 44, // 4: geyser.SubscribeRequest.blocks:type_name -> geyser.SubscribeRequest.BlocksEntry - 45, // 5: geyser.SubscribeRequest.blocks_meta:type_name -> geyser.SubscribeRequest.BlocksMetaEntry - 46, // 6: geyser.SubscribeRequest.entry:type_name -> geyser.SubscribeRequest.EntryEntry - 0, // 7: geyser.SubscribeRequest.commitment:type_name -> geyser.CommitmentLevel - 12, // 8: geyser.SubscribeRequest.accounts_data_slice:type_name -> geyser.SubscribeRequestAccountsDataSlice - 13, // 9: geyser.SubscribeRequest.ping:type_name -> geyser.SubscribeRequestPing - 4, // 10: geyser.SubscribeRequestFilterAccounts.filters:type_name -> geyser.SubscribeRequestFilterAccountsFilter - 5, // 11: geyser.SubscribeRequestFilterAccountsFilter.memcmp:type_name -> geyser.SubscribeRequestFilterAccountsFilterMemcmp - 6, // 12: geyser.SubscribeRequestFilterAccountsFilter.lamports:type_name -> geyser.SubscribeRequestFilterAccountsFilterLamports - 15, // 13: geyser.SubscribeUpdate.account:type_name -> geyser.SubscribeUpdateAccount - 17, // 14: geyser.SubscribeUpdate.slot:type_name -> geyser.SubscribeUpdateSlot - 18, // 15: geyser.SubscribeUpdate.transaction:type_name -> geyser.SubscribeUpdateTransaction - 20, // 16: geyser.SubscribeUpdate.transaction_status:type_name -> geyser.SubscribeUpdateTransactionStatus - 21, // 17: geyser.SubscribeUpdate.block:type_name -> geyser.SubscribeUpdateBlock - 24, // 18: geyser.SubscribeUpdate.ping:type_name -> geyser.SubscribeUpdatePing - 25, // 19: geyser.SubscribeUpdate.pong:type_name -> geyser.SubscribeUpdatePong - 22, // 20: geyser.SubscribeUpdate.block_meta:type_name -> geyser.SubscribeUpdateBlockMeta - 23, // 21: geyser.SubscribeUpdate.entry:type_name -> geyser.SubscribeUpdateEntry - 47, // 22: geyser.SubscribeUpdate.created_at:type_name -> google.protobuf.Timestamp - 16, // 23: geyser.SubscribeUpdateAccount.account:type_name -> geyser.SubscribeUpdateAccountInfo - 1, // 24: geyser.SubscribeUpdateSlot.status:type_name -> geyser.SlotStatus - 19, // 25: geyser.SubscribeUpdateTransaction.transaction:type_name -> geyser.SubscribeUpdateTransactionInfo - 48, // 26: geyser.SubscribeUpdateTransactionInfo.transaction:type_name -> solana.storage.ConfirmedBlock.Transaction - 49, // 27: geyser.SubscribeUpdateTransactionInfo.meta:type_name -> solana.storage.ConfirmedBlock.TransactionStatusMeta - 50, // 28: geyser.SubscribeUpdateTransactionStatus.err:type_name -> solana.storage.ConfirmedBlock.TransactionError - 51, // 29: geyser.SubscribeUpdateBlock.rewards:type_name -> solana.storage.ConfirmedBlock.Rewards - 52, // 30: geyser.SubscribeUpdateBlock.block_time:type_name -> solana.storage.ConfirmedBlock.UnixTimestamp - 53, // 31: geyser.SubscribeUpdateBlock.block_height:type_name -> solana.storage.ConfirmedBlock.BlockHeight - 19, // 32: geyser.SubscribeUpdateBlock.transactions:type_name -> geyser.SubscribeUpdateTransactionInfo - 16, // 33: geyser.SubscribeUpdateBlock.accounts:type_name -> geyser.SubscribeUpdateAccountInfo - 23, // 34: geyser.SubscribeUpdateBlock.entries:type_name -> geyser.SubscribeUpdateEntry - 51, // 35: geyser.SubscribeUpdateBlockMeta.rewards:type_name -> solana.storage.ConfirmedBlock.Rewards - 52, // 36: geyser.SubscribeUpdateBlockMeta.block_time:type_name -> solana.storage.ConfirmedBlock.UnixTimestamp - 53, // 37: geyser.SubscribeUpdateBlockMeta.block_height:type_name -> solana.storage.ConfirmedBlock.BlockHeight - 0, // 38: geyser.GetLatestBlockhashRequest.commitment:type_name -> geyser.CommitmentLevel - 0, // 39: geyser.GetBlockHeightRequest.commitment:type_name -> geyser.CommitmentLevel - 0, // 40: geyser.GetSlotRequest.commitment:type_name -> geyser.CommitmentLevel - 0, // 41: geyser.IsBlockhashValidRequest.commitment:type_name -> geyser.CommitmentLevel - 3, // 42: geyser.SubscribeRequest.AccountsEntry.value:type_name -> geyser.SubscribeRequestFilterAccounts - 7, // 43: geyser.SubscribeRequest.SlotsEntry.value:type_name -> geyser.SubscribeRequestFilterSlots - 8, // 44: geyser.SubscribeRequest.TransactionsEntry.value:type_name -> geyser.SubscribeRequestFilterTransactions - 8, // 45: geyser.SubscribeRequest.TransactionsStatusEntry.value:type_name -> geyser.SubscribeRequestFilterTransactions - 9, // 46: geyser.SubscribeRequest.BlocksEntry.value:type_name -> geyser.SubscribeRequestFilterBlocks - 10, // 47: geyser.SubscribeRequest.BlocksMetaEntry.value:type_name -> geyser.SubscribeRequestFilterBlocksMeta - 11, // 48: geyser.SubscribeRequest.EntryEntry.value:type_name -> geyser.SubscribeRequestFilterEntry - 2, // 49: geyser.Geyser.Subscribe:input_type -> geyser.SubscribeRequest - 26, // 50: geyser.Geyser.SubscribeReplayInfo:input_type -> geyser.SubscribeReplayInfoRequest - 28, // 51: geyser.Geyser.Ping:input_type -> geyser.PingRequest - 30, // 52: geyser.Geyser.GetLatestBlockhash:input_type -> geyser.GetLatestBlockhashRequest - 32, // 53: geyser.Geyser.GetBlockHeight:input_type -> geyser.GetBlockHeightRequest - 34, // 54: geyser.Geyser.GetSlot:input_type -> geyser.GetSlotRequest - 38, // 55: geyser.Geyser.IsBlockhashValid:input_type -> geyser.IsBlockhashValidRequest - 36, // 56: geyser.Geyser.GetVersion:input_type -> geyser.GetVersionRequest - 14, // 57: geyser.Geyser.Subscribe:output_type -> geyser.SubscribeUpdate - 27, // 58: geyser.Geyser.SubscribeReplayInfo:output_type -> geyser.SubscribeReplayInfoResponse - 29, // 59: geyser.Geyser.Ping:output_type -> geyser.PongResponse - 31, // 60: geyser.Geyser.GetLatestBlockhash:output_type -> geyser.GetLatestBlockhashResponse - 33, // 61: geyser.Geyser.GetBlockHeight:output_type -> geyser.GetBlockHeightResponse - 35, // 62: geyser.Geyser.GetSlot:output_type -> geyser.GetSlotResponse - 39, // 63: geyser.Geyser.IsBlockhashValid:output_type -> geyser.IsBlockhashValidResponse - 37, // 64: geyser.Geyser.GetVersion:output_type -> geyser.GetVersionResponse - 57, // [57:65] is the sub-list for method output_type - 49, // [49:57] is the sub-list for method input_type - 49, // [49:49] is the sub-list for extension type_name - 49, // [49:49] is the sub-list for extension extendee - 0, // [0:49] is the sub-list for field type_name -} - -func init() { file_geyser_proto_init() } -func file_geyser_proto_init() { - if File_geyser_proto != nil { - return - } - file_solana_storage_proto_init() - file_geyser_proto_msgTypes[0].OneofWrappers = []any{} - file_geyser_proto_msgTypes[1].OneofWrappers = []any{} - file_geyser_proto_msgTypes[2].OneofWrappers = []any{ - (*SubscribeRequestFilterAccountsFilter_Memcmp)(nil), - (*SubscribeRequestFilterAccountsFilter_Datasize)(nil), - (*SubscribeRequestFilterAccountsFilter_TokenAccountState)(nil), - (*SubscribeRequestFilterAccountsFilter_Lamports)(nil), - } - file_geyser_proto_msgTypes[3].OneofWrappers = []any{ - (*SubscribeRequestFilterAccountsFilterMemcmp_Bytes)(nil), - (*SubscribeRequestFilterAccountsFilterMemcmp_Base58)(nil), - (*SubscribeRequestFilterAccountsFilterMemcmp_Base64)(nil), - } - file_geyser_proto_msgTypes[4].OneofWrappers = []any{ - (*SubscribeRequestFilterAccountsFilterLamports_Eq)(nil), - (*SubscribeRequestFilterAccountsFilterLamports_Ne)(nil), - (*SubscribeRequestFilterAccountsFilterLamports_Lt)(nil), - (*SubscribeRequestFilterAccountsFilterLamports_Gt)(nil), - } - file_geyser_proto_msgTypes[5].OneofWrappers = []any{} - file_geyser_proto_msgTypes[6].OneofWrappers = []any{} - file_geyser_proto_msgTypes[7].OneofWrappers = []any{} - file_geyser_proto_msgTypes[12].OneofWrappers = []any{ - (*SubscribeUpdate_Account)(nil), - (*SubscribeUpdate_Slot)(nil), - (*SubscribeUpdate_Transaction)(nil), - (*SubscribeUpdate_TransactionStatus)(nil), - (*SubscribeUpdate_Block)(nil), - (*SubscribeUpdate_Ping)(nil), - (*SubscribeUpdate_Pong)(nil), - (*SubscribeUpdate_BlockMeta)(nil), - (*SubscribeUpdate_Entry)(nil), - } - file_geyser_proto_msgTypes[14].OneofWrappers = []any{} - file_geyser_proto_msgTypes[15].OneofWrappers = []any{} - file_geyser_proto_msgTypes[25].OneofWrappers = []any{} - file_geyser_proto_msgTypes[28].OneofWrappers = []any{} - file_geyser_proto_msgTypes[30].OneofWrappers = []any{} - file_geyser_proto_msgTypes[32].OneofWrappers = []any{} - file_geyser_proto_msgTypes[36].OneofWrappers = []any{} - type x struct{} - out := protoimpl.TypeBuilder{ - File: protoimpl.DescBuilder{ - GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: unsafe.Slice(unsafe.StringData(file_geyser_proto_rawDesc), len(file_geyser_proto_rawDesc)), - NumEnums: 2, - NumMessages: 45, - NumExtensions: 0, - NumServices: 1, - }, - GoTypes: file_geyser_proto_goTypes, - DependencyIndexes: file_geyser_proto_depIdxs, - EnumInfos: file_geyser_proto_enumTypes, - MessageInfos: file_geyser_proto_msgTypes, - }.Build() - File_geyser_proto = out.File - file_geyser_proto_goTypes = nil - file_geyser_proto_depIdxs = nil -} diff --git a/pkg/grpc/pb/geyser.proto b/pkg/grpc/pb/geyser.proto deleted file mode 100644 index 00320bcb..00000000 --- a/pkg/grpc/pb/geyser.proto +++ /dev/null @@ -1,279 +0,0 @@ -syntax = "proto3"; - -import "google/protobuf/timestamp.proto"; -import "solana-storage.proto"; - -option go_package = "github.com/Overclock-Validator/mithril/pkg/grpc/pb"; - -package geyser; - -service Geyser { - rpc Subscribe(stream SubscribeRequest) returns (stream SubscribeUpdate) {} - rpc SubscribeReplayInfo(SubscribeReplayInfoRequest) returns (SubscribeReplayInfoResponse) {} - rpc Ping(PingRequest) returns (PongResponse) {} - rpc GetLatestBlockhash(GetLatestBlockhashRequest) returns (GetLatestBlockhashResponse) {} - rpc GetBlockHeight(GetBlockHeightRequest) returns (GetBlockHeightResponse) {} - rpc GetSlot(GetSlotRequest) returns (GetSlotResponse) {} - rpc IsBlockhashValid(IsBlockhashValidRequest) returns (IsBlockhashValidResponse) {} - rpc GetVersion(GetVersionRequest) returns (GetVersionResponse) {} -} - -enum CommitmentLevel { - PROCESSED = 0; - CONFIRMED = 1; - FINALIZED = 2; -} - -enum SlotStatus { - SLOT_PROCESSED = 0; - SLOT_CONFIRMED = 1; - SLOT_FINALIZED = 2; - SLOT_FIRST_SHRED_RECEIVED = 3; - SLOT_COMPLETED = 4; - SLOT_CREATED_BANK = 5; - SLOT_DEAD = 6; -} - -message SubscribeRequest { - map accounts = 1; - map slots = 2; - map transactions = 3; - map transactions_status = 10; - map blocks = 4; - map blocks_meta = 5; - map entry = 8; - optional CommitmentLevel commitment = 6; - repeated SubscribeRequestAccountsDataSlice accounts_data_slice = 7; - optional SubscribeRequestPing ping = 9; - optional uint64 from_slot = 11; -} - -message SubscribeRequestFilterAccounts { - repeated string account = 2; - repeated string owner = 3; - repeated SubscribeRequestFilterAccountsFilter filters = 4; - optional bool nonempty_txn_signature = 5; -} - -message SubscribeRequestFilterAccountsFilter { - oneof filter { - SubscribeRequestFilterAccountsFilterMemcmp memcmp = 1; - uint64 datasize = 2; - bool token_account_state = 3; - SubscribeRequestFilterAccountsFilterLamports lamports = 4; - } -} - -message SubscribeRequestFilterAccountsFilterMemcmp { - uint64 offset = 1; - oneof data { - bytes bytes = 2; - string base58 = 3; - string base64 = 4; - } -} - -message SubscribeRequestFilterAccountsFilterLamports { - oneof cmp { - uint64 eq = 1; - uint64 ne = 2; - uint64 lt = 3; - uint64 gt = 4; - } -} - -message SubscribeRequestFilterSlots { - optional bool filter_by_commitment = 1; - optional bool interslot_updates = 2; -} - -message SubscribeRequestFilterTransactions { - optional bool vote = 1; - optional bool failed = 2; - optional string signature = 5; - repeated string account_include = 3; - repeated string account_exclude = 4; - repeated string account_required = 6; -} - -message SubscribeRequestFilterBlocks { - repeated string account_include = 1; - optional bool include_transactions = 2; - optional bool include_accounts = 3; - optional bool include_entries = 4; -} - -message SubscribeRequestFilterBlocksMeta {} - -message SubscribeRequestFilterEntry {} - -message SubscribeRequestAccountsDataSlice { - uint64 offset = 1; - uint64 length = 2; -} - -message SubscribeRequestPing { - int32 id = 1; -} - -message SubscribeUpdate { - repeated string filters = 1; - oneof update_oneof { - SubscribeUpdateAccount account = 2; - SubscribeUpdateSlot slot = 3; - SubscribeUpdateTransaction transaction = 4; - SubscribeUpdateTransactionStatus transaction_status = 10; - SubscribeUpdateBlock block = 5; - SubscribeUpdatePing ping = 6; - SubscribeUpdatePong pong = 9; - SubscribeUpdateBlockMeta block_meta = 7; - SubscribeUpdateEntry entry = 8; - } - google.protobuf.Timestamp created_at = 11; -} - -message SubscribeUpdateAccount { - SubscribeUpdateAccountInfo account = 1; - uint64 slot = 2; - bool is_startup = 3; -} - -message SubscribeUpdateAccountInfo { - bytes pubkey = 1; - uint64 lamports = 2; - bytes owner = 3; - bool executable = 4; - uint64 rent_epoch = 5; - bytes data = 6; - uint64 write_version = 7; - optional bytes txn_signature = 8; -} - -message SubscribeUpdateSlot { - uint64 slot = 1; - optional uint64 parent = 2; - SlotStatus status = 3; - optional string dead_error = 4; -} - -message SubscribeUpdateTransaction { - SubscribeUpdateTransactionInfo transaction = 1; - uint64 slot = 2; -} - -message SubscribeUpdateTransactionInfo { - bytes signature = 1; - bool is_vote = 2; - solana.storage.ConfirmedBlock.Transaction transaction = 3; - solana.storage.ConfirmedBlock.TransactionStatusMeta meta = 4; - uint64 index = 5; -} - -message SubscribeUpdateTransactionStatus { - uint64 slot = 1; - bytes signature = 2; - bool is_vote = 3; - uint64 index = 4; - solana.storage.ConfirmedBlock.TransactionError err = 5; -} - -message SubscribeUpdateBlock { - uint64 slot = 1; - string blockhash = 2; - solana.storage.ConfirmedBlock.Rewards rewards = 3; - solana.storage.ConfirmedBlock.UnixTimestamp block_time = 4; - solana.storage.ConfirmedBlock.BlockHeight block_height = 5; - uint64 parent_slot = 7; - string parent_blockhash = 8; - uint64 executed_transaction_count = 9; - repeated SubscribeUpdateTransactionInfo transactions = 6; - uint64 updated_account_count = 10; - repeated SubscribeUpdateAccountInfo accounts = 11; - uint64 entries_count = 12; - repeated SubscribeUpdateEntry entries = 13; -} - -message SubscribeUpdateBlockMeta { - uint64 slot = 1; - string blockhash = 2; - solana.storage.ConfirmedBlock.Rewards rewards = 3; - solana.storage.ConfirmedBlock.UnixTimestamp block_time = 4; - solana.storage.ConfirmedBlock.BlockHeight block_height = 5; - uint64 parent_slot = 6; - string parent_blockhash = 7; - uint64 executed_transaction_count = 8; - uint64 entries_count = 9; -} - -message SubscribeUpdateEntry { - uint64 slot = 1; - uint64 index = 2; - uint64 num_hashes = 3; - bytes hash = 4; - uint64 executed_transaction_count = 5; - uint64 starting_transaction_index = 6; // added in v1.18, for solana 1.17 value is always 0 -} - -message SubscribeUpdatePing {} - -message SubscribeUpdatePong { - int32 id = 1; -} - -// non-streaming methods - -message SubscribeReplayInfoRequest {} - -message SubscribeReplayInfoResponse { - optional uint64 first_available = 1; -} - -message PingRequest { - int32 count = 1; -} - -message PongResponse { - int32 count = 1; -} - -message GetLatestBlockhashRequest { - optional CommitmentLevel commitment = 1; -} - -message GetLatestBlockhashResponse { - uint64 slot = 1; - string blockhash = 2; - uint64 last_valid_block_height = 3; -} - -message GetBlockHeightRequest { - optional CommitmentLevel commitment = 1; -} - -message GetBlockHeightResponse { - uint64 block_height = 1; -} - -message GetSlotRequest { - optional CommitmentLevel commitment = 1; -} - -message GetSlotResponse { - uint64 slot = 1; -} - -message GetVersionRequest {} - -message GetVersionResponse { - string version = 1; -} - -message IsBlockhashValidRequest { - string blockhash = 1; - optional CommitmentLevel commitment = 2; -} - -message IsBlockhashValidResponse { - uint64 slot = 1; - bool valid = 2; -} diff --git a/pkg/grpc/pb/geyser_grpc.pb.go b/pkg/grpc/pb/geyser_grpc.pb.go deleted file mode 100644 index ab27fadd..00000000 --- a/pkg/grpc/pb/geyser_grpc.pb.go +++ /dev/null @@ -1,382 +0,0 @@ -// Code generated by protoc-gen-go-grpc. DO NOT EDIT. -// versions: -// - protoc-gen-go-grpc v1.6.0 -// - protoc v5.28.0 -// source: geyser.proto - -package pb - -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 ( - Geyser_Subscribe_FullMethodName = "/geyser.Geyser/Subscribe" - Geyser_SubscribeReplayInfo_FullMethodName = "/geyser.Geyser/SubscribeReplayInfo" - Geyser_Ping_FullMethodName = "/geyser.Geyser/Ping" - Geyser_GetLatestBlockhash_FullMethodName = "/geyser.Geyser/GetLatestBlockhash" - Geyser_GetBlockHeight_FullMethodName = "/geyser.Geyser/GetBlockHeight" - Geyser_GetSlot_FullMethodName = "/geyser.Geyser/GetSlot" - Geyser_IsBlockhashValid_FullMethodName = "/geyser.Geyser/IsBlockhashValid" - Geyser_GetVersion_FullMethodName = "/geyser.Geyser/GetVersion" -) - -// 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 { - Subscribe(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[SubscribeRequest, SubscribeUpdate], error) - SubscribeReplayInfo(ctx context.Context, in *SubscribeReplayInfoRequest, opts ...grpc.CallOption) (*SubscribeReplayInfoResponse, error) - Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error) - GetLatestBlockhash(ctx context.Context, in *GetLatestBlockhashRequest, opts ...grpc.CallOption) (*GetLatestBlockhashResponse, error) - GetBlockHeight(ctx context.Context, in *GetBlockHeightRequest, opts ...grpc.CallOption) (*GetBlockHeightResponse, error) - GetSlot(ctx context.Context, in *GetSlotRequest, opts ...grpc.CallOption) (*GetSlotResponse, error) - IsBlockhashValid(ctx context.Context, in *IsBlockhashValidRequest, opts ...grpc.CallOption) (*IsBlockhashValidResponse, error) - GetVersion(ctx context.Context, in *GetVersionRequest, opts ...grpc.CallOption) (*GetVersionResponse, error) -} - -type geyserClient struct { - cc grpc.ClientConnInterface -} - -func NewGeyserClient(cc grpc.ClientConnInterface) GeyserClient { - return &geyserClient{cc} -} - -func (c *geyserClient) Subscribe(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[SubscribeRequest, SubscribeUpdate], error) { - cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) - stream, err := c.cc.NewStream(ctx, &Geyser_ServiceDesc.Streams[0], Geyser_Subscribe_FullMethodName, cOpts...) - if err != nil { - return nil, err - } - x := &grpc.GenericClientStream[SubscribeRequest, SubscribeUpdate]{ClientStream: stream} - 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 Geyser_SubscribeClient = grpc.BidiStreamingClient[SubscribeRequest, SubscribeUpdate] - -func (c *geyserClient) SubscribeReplayInfo(ctx context.Context, in *SubscribeReplayInfoRequest, opts ...grpc.CallOption) (*SubscribeReplayInfoResponse, error) { - cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) - out := new(SubscribeReplayInfoResponse) - err := c.cc.Invoke(ctx, Geyser_SubscribeReplayInfo_FullMethodName, in, out, cOpts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *geyserClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error) { - cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) - out := new(PongResponse) - err := c.cc.Invoke(ctx, Geyser_Ping_FullMethodName, in, out, cOpts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *geyserClient) GetLatestBlockhash(ctx context.Context, in *GetLatestBlockhashRequest, opts ...grpc.CallOption) (*GetLatestBlockhashResponse, error) { - cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) - out := new(GetLatestBlockhashResponse) - err := c.cc.Invoke(ctx, Geyser_GetLatestBlockhash_FullMethodName, in, out, cOpts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *geyserClient) GetBlockHeight(ctx context.Context, in *GetBlockHeightRequest, opts ...grpc.CallOption) (*GetBlockHeightResponse, error) { - cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) - out := new(GetBlockHeightResponse) - err := c.cc.Invoke(ctx, Geyser_GetBlockHeight_FullMethodName, in, out, cOpts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *geyserClient) GetSlot(ctx context.Context, in *GetSlotRequest, opts ...grpc.CallOption) (*GetSlotResponse, error) { - cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) - out := new(GetSlotResponse) - err := c.cc.Invoke(ctx, Geyser_GetSlot_FullMethodName, in, out, cOpts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *geyserClient) IsBlockhashValid(ctx context.Context, in *IsBlockhashValidRequest, opts ...grpc.CallOption) (*IsBlockhashValidResponse, error) { - cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) - out := new(IsBlockhashValidResponse) - err := c.cc.Invoke(ctx, Geyser_IsBlockhashValid_FullMethodName, in, out, cOpts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *geyserClient) GetVersion(ctx context.Context, in *GetVersionRequest, opts ...grpc.CallOption) (*GetVersionResponse, error) { - cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) - out := new(GetVersionResponse) - err := c.cc.Invoke(ctx, Geyser_GetVersion_FullMethodName, in, out, cOpts...) - if err != nil { - return nil, err - } - return out, nil -} - -// GeyserServer is the server API for Geyser service. -// All implementations must embed UnimplementedGeyserServer -// for forward compatibility. -type GeyserServer interface { - Subscribe(grpc.BidiStreamingServer[SubscribeRequest, SubscribeUpdate]) error - SubscribeReplayInfo(context.Context, *SubscribeReplayInfoRequest) (*SubscribeReplayInfoResponse, error) - Ping(context.Context, *PingRequest) (*PongResponse, error) - GetLatestBlockhash(context.Context, *GetLatestBlockhashRequest) (*GetLatestBlockhashResponse, error) - GetBlockHeight(context.Context, *GetBlockHeightRequest) (*GetBlockHeightResponse, error) - GetSlot(context.Context, *GetSlotRequest) (*GetSlotResponse, error) - IsBlockhashValid(context.Context, *IsBlockhashValidRequest) (*IsBlockhashValidResponse, error) - GetVersion(context.Context, *GetVersionRequest) (*GetVersionResponse, error) - mustEmbedUnimplementedGeyserServer() -} - -// UnimplementedGeyserServer 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 UnimplementedGeyserServer struct{} - -func (UnimplementedGeyserServer) Subscribe(grpc.BidiStreamingServer[SubscribeRequest, SubscribeUpdate]) error { - return status.Error(codes.Unimplemented, "method Subscribe not implemented") -} -func (UnimplementedGeyserServer) SubscribeReplayInfo(context.Context, *SubscribeReplayInfoRequest) (*SubscribeReplayInfoResponse, error) { - return nil, status.Error(codes.Unimplemented, "method SubscribeReplayInfo not implemented") -} -func (UnimplementedGeyserServer) Ping(context.Context, *PingRequest) (*PongResponse, error) { - return nil, status.Error(codes.Unimplemented, "method Ping not implemented") -} -func (UnimplementedGeyserServer) GetLatestBlockhash(context.Context, *GetLatestBlockhashRequest) (*GetLatestBlockhashResponse, error) { - return nil, status.Error(codes.Unimplemented, "method GetLatestBlockhash not implemented") -} -func (UnimplementedGeyserServer) GetBlockHeight(context.Context, *GetBlockHeightRequest) (*GetBlockHeightResponse, error) { - return nil, status.Error(codes.Unimplemented, "method GetBlockHeight not implemented") -} -func (UnimplementedGeyserServer) GetSlot(context.Context, *GetSlotRequest) (*GetSlotResponse, error) { - return nil, status.Error(codes.Unimplemented, "method GetSlot not implemented") -} -func (UnimplementedGeyserServer) IsBlockhashValid(context.Context, *IsBlockhashValidRequest) (*IsBlockhashValidResponse, error) { - return nil, status.Error(codes.Unimplemented, "method IsBlockhashValid not implemented") -} -func (UnimplementedGeyserServer) GetVersion(context.Context, *GetVersionRequest) (*GetVersionResponse, error) { - return nil, status.Error(codes.Unimplemented, "method GetVersion not implemented") -} -func (UnimplementedGeyserServer) mustEmbedUnimplementedGeyserServer() {} -func (UnimplementedGeyserServer) testEmbeddedByValue() {} - -// 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) { - // If the following call panics, it indicates UnimplementedGeyserServer 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(&Geyser_ServiceDesc, srv) -} - -func _Geyser_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(GeyserServer).Subscribe(&grpc.GenericServerStream[SubscribeRequest, SubscribeUpdate]{ServerStream: stream}) -} - -// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. -type Geyser_SubscribeServer = grpc.BidiStreamingServer[SubscribeRequest, SubscribeUpdate] - -func _Geyser_SubscribeReplayInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SubscribeReplayInfoRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(GeyserServer).SubscribeReplayInfo(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: Geyser_SubscribeReplayInfo_FullMethodName, - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(GeyserServer).SubscribeReplayInfo(ctx, req.(*SubscribeReplayInfoRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _Geyser_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(PingRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(GeyserServer).Ping(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: Geyser_Ping_FullMethodName, - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(GeyserServer).Ping(ctx, req.(*PingRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _Geyser_GetLatestBlockhash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetLatestBlockhashRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(GeyserServer).GetLatestBlockhash(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: Geyser_GetLatestBlockhash_FullMethodName, - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(GeyserServer).GetLatestBlockhash(ctx, req.(*GetLatestBlockhashRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _Geyser_GetBlockHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetBlockHeightRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(GeyserServer).GetBlockHeight(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: Geyser_GetBlockHeight_FullMethodName, - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(GeyserServer).GetBlockHeight(ctx, req.(*GetBlockHeightRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _Geyser_GetSlot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetSlotRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(GeyserServer).GetSlot(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: Geyser_GetSlot_FullMethodName, - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(GeyserServer).GetSlot(ctx, req.(*GetSlotRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _Geyser_IsBlockhashValid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(IsBlockhashValidRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(GeyserServer).IsBlockhashValid(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: Geyser_IsBlockhashValid_FullMethodName, - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(GeyserServer).IsBlockhashValid(ctx, req.(*IsBlockhashValidRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _Geyser_GetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetVersionRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(GeyserServer).GetVersion(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: Geyser_GetVersion_FullMethodName, - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(GeyserServer).GetVersion(ctx, req.(*GetVersionRequest)) - } - return interceptor(ctx, in, info, handler) -} - -// 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: "geyser.Geyser", - HandlerType: (*GeyserServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "SubscribeReplayInfo", - Handler: _Geyser_SubscribeReplayInfo_Handler, - }, - { - MethodName: "Ping", - Handler: _Geyser_Ping_Handler, - }, - { - MethodName: "GetLatestBlockhash", - Handler: _Geyser_GetLatestBlockhash_Handler, - }, - { - MethodName: "GetBlockHeight", - Handler: _Geyser_GetBlockHeight_Handler, - }, - { - MethodName: "GetSlot", - Handler: _Geyser_GetSlot_Handler, - }, - { - MethodName: "IsBlockhashValid", - Handler: _Geyser_IsBlockhashValid_Handler, - }, - { - MethodName: "GetVersion", - Handler: _Geyser_GetVersion_Handler, - }, - }, - Streams: []grpc.StreamDesc{ - { - StreamName: "Subscribe", - Handler: _Geyser_Subscribe_Handler, - ServerStreams: true, - ClientStreams: true, - }, - }, - Metadata: "geyser.proto", -} diff --git a/pkg/grpc/pb/solana-storage.pb.go b/pkg/grpc/pb/solana-storage.pb.go deleted file mode 100644 index baf93989..00000000 --- a/pkg/grpc/pb/solana-storage.pb.go +++ /dev/null @@ -1,1559 +0,0 @@ -// Code generated by protoc-gen-go. DO NOT EDIT. -// versions: -// protoc-gen-go v1.36.10 -// protoc v5.28.0 -// source: solana-storage.proto - -package pb - -import ( - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" - reflect "reflect" - sync "sync" - unsafe "unsafe" -) - -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) -) - -type RewardType int32 - -const ( - RewardType_Unspecified RewardType = 0 - RewardType_Fee RewardType = 1 - RewardType_Rent RewardType = 2 - RewardType_Staking RewardType = 3 - RewardType_Voting RewardType = 4 -) - -// Enum value maps for RewardType. -var ( - RewardType_name = map[int32]string{ - 0: "Unspecified", - 1: "Fee", - 2: "Rent", - 3: "Staking", - 4: "Voting", - } - RewardType_value = map[string]int32{ - "Unspecified": 0, - "Fee": 1, - "Rent": 2, - "Staking": 3, - "Voting": 4, - } -) - -func (x RewardType) Enum() *RewardType { - p := new(RewardType) - *p = x - return p -} - -func (x RewardType) String() string { - return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) -} - -func (RewardType) Descriptor() protoreflect.EnumDescriptor { - return file_solana_storage_proto_enumTypes[0].Descriptor() -} - -func (RewardType) Type() protoreflect.EnumType { - return &file_solana_storage_proto_enumTypes[0] -} - -func (x RewardType) Number() protoreflect.EnumNumber { - return protoreflect.EnumNumber(x) -} - -// Deprecated: Use RewardType.Descriptor instead. -func (RewardType) EnumDescriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{0} -} - -type ConfirmedBlock struct { - state protoimpl.MessageState `protogen:"open.v1"` - PreviousBlockhash string `protobuf:"bytes,1,opt,name=previous_blockhash,json=previousBlockhash,proto3" json:"previous_blockhash,omitempty"` - Blockhash string `protobuf:"bytes,2,opt,name=blockhash,proto3" json:"blockhash,omitempty"` - ParentSlot uint64 `protobuf:"varint,3,opt,name=parent_slot,json=parentSlot,proto3" json:"parent_slot,omitempty"` - Transactions []*ConfirmedTransaction `protobuf:"bytes,4,rep,name=transactions,proto3" json:"transactions,omitempty"` - Rewards []*Reward `protobuf:"bytes,5,rep,name=rewards,proto3" json:"rewards,omitempty"` - BlockTime *UnixTimestamp `protobuf:"bytes,6,opt,name=block_time,json=blockTime,proto3" json:"block_time,omitempty"` - BlockHeight *BlockHeight `protobuf:"bytes,7,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` - NumPartitions *NumPartitions `protobuf:"bytes,8,opt,name=num_partitions,json=numPartitions,proto3" json:"num_partitions,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ConfirmedBlock) Reset() { - *x = ConfirmedBlock{} - mi := &file_solana_storage_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ConfirmedBlock) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ConfirmedBlock) ProtoMessage() {} - -func (x *ConfirmedBlock) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[0] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use ConfirmedBlock.ProtoReflect.Descriptor instead. -func (*ConfirmedBlock) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{0} -} - -func (x *ConfirmedBlock) GetPreviousBlockhash() string { - if x != nil { - return x.PreviousBlockhash - } - return "" -} - -func (x *ConfirmedBlock) GetBlockhash() string { - if x != nil { - return x.Blockhash - } - return "" -} - -func (x *ConfirmedBlock) GetParentSlot() uint64 { - if x != nil { - return x.ParentSlot - } - return 0 -} - -func (x *ConfirmedBlock) GetTransactions() []*ConfirmedTransaction { - if x != nil { - return x.Transactions - } - return nil -} - -func (x *ConfirmedBlock) GetRewards() []*Reward { - if x != nil { - return x.Rewards - } - return nil -} - -func (x *ConfirmedBlock) GetBlockTime() *UnixTimestamp { - if x != nil { - return x.BlockTime - } - return nil -} - -func (x *ConfirmedBlock) GetBlockHeight() *BlockHeight { - if x != nil { - return x.BlockHeight - } - return nil -} - -func (x *ConfirmedBlock) GetNumPartitions() *NumPartitions { - if x != nil { - return x.NumPartitions - } - return nil -} - -type ConfirmedTransaction struct { - state protoimpl.MessageState `protogen:"open.v1"` - Transaction *Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"` - Meta *TransactionStatusMeta `protobuf:"bytes,2,opt,name=meta,proto3" json:"meta,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ConfirmedTransaction) Reset() { - *x = ConfirmedTransaction{} - mi := &file_solana_storage_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ConfirmedTransaction) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ConfirmedTransaction) ProtoMessage() {} - -func (x *ConfirmedTransaction) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[1] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use ConfirmedTransaction.ProtoReflect.Descriptor instead. -func (*ConfirmedTransaction) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{1} -} - -func (x *ConfirmedTransaction) GetTransaction() *Transaction { - if x != nil { - return x.Transaction - } - return nil -} - -func (x *ConfirmedTransaction) GetMeta() *TransactionStatusMeta { - if x != nil { - return x.Meta - } - return nil -} - -type Transaction struct { - state protoimpl.MessageState `protogen:"open.v1"` - Signatures [][]byte `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"` - Message *Message `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *Transaction) Reset() { - *x = Transaction{} - mi := &file_solana_storage_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *Transaction) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Transaction) ProtoMessage() {} - -func (x *Transaction) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[2] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Transaction.ProtoReflect.Descriptor instead. -func (*Transaction) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{2} -} - -func (x *Transaction) GetSignatures() [][]byte { - if x != nil { - return x.Signatures - } - return nil -} - -func (x *Transaction) GetMessage() *Message { - if x != nil { - return x.Message - } - return nil -} - -type Message struct { - state protoimpl.MessageState `protogen:"open.v1"` - Header *MessageHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - AccountKeys [][]byte `protobuf:"bytes,2,rep,name=account_keys,json=accountKeys,proto3" json:"account_keys,omitempty"` - RecentBlockhash []byte `protobuf:"bytes,3,opt,name=recent_blockhash,json=recentBlockhash,proto3" json:"recent_blockhash,omitempty"` - Instructions []*CompiledInstruction `protobuf:"bytes,4,rep,name=instructions,proto3" json:"instructions,omitempty"` - Versioned bool `protobuf:"varint,5,opt,name=versioned,proto3" json:"versioned,omitempty"` - AddressTableLookups []*MessageAddressTableLookup `protobuf:"bytes,6,rep,name=address_table_lookups,json=addressTableLookups,proto3" json:"address_table_lookups,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *Message) Reset() { - *x = Message{} - mi := &file_solana_storage_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *Message) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Message) ProtoMessage() {} - -func (x *Message) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[3] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Message.ProtoReflect.Descriptor instead. -func (*Message) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{3} -} - -func (x *Message) GetHeader() *MessageHeader { - if x != nil { - return x.Header - } - return nil -} - -func (x *Message) GetAccountKeys() [][]byte { - if x != nil { - return x.AccountKeys - } - return nil -} - -func (x *Message) GetRecentBlockhash() []byte { - if x != nil { - return x.RecentBlockhash - } - return nil -} - -func (x *Message) GetInstructions() []*CompiledInstruction { - if x != nil { - return x.Instructions - } - return nil -} - -func (x *Message) GetVersioned() bool { - if x != nil { - return x.Versioned - } - return false -} - -func (x *Message) GetAddressTableLookups() []*MessageAddressTableLookup { - if x != nil { - return x.AddressTableLookups - } - return nil -} - -type MessageHeader struct { - state protoimpl.MessageState `protogen:"open.v1"` - NumRequiredSignatures uint32 `protobuf:"varint,1,opt,name=num_required_signatures,json=numRequiredSignatures,proto3" json:"num_required_signatures,omitempty"` - NumReadonlySignedAccounts uint32 `protobuf:"varint,2,opt,name=num_readonly_signed_accounts,json=numReadonlySignedAccounts,proto3" json:"num_readonly_signed_accounts,omitempty"` - NumReadonlyUnsignedAccounts uint32 `protobuf:"varint,3,opt,name=num_readonly_unsigned_accounts,json=numReadonlyUnsignedAccounts,proto3" json:"num_readonly_unsigned_accounts,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *MessageHeader) Reset() { - *x = MessageHeader{} - mi := &file_solana_storage_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *MessageHeader) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*MessageHeader) ProtoMessage() {} - -func (x *MessageHeader) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[4] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use MessageHeader.ProtoReflect.Descriptor instead. -func (*MessageHeader) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{4} -} - -func (x *MessageHeader) GetNumRequiredSignatures() uint32 { - if x != nil { - return x.NumRequiredSignatures - } - return 0 -} - -func (x *MessageHeader) GetNumReadonlySignedAccounts() uint32 { - if x != nil { - return x.NumReadonlySignedAccounts - } - return 0 -} - -func (x *MessageHeader) GetNumReadonlyUnsignedAccounts() uint32 { - if x != nil { - return x.NumReadonlyUnsignedAccounts - } - return 0 -} - -type MessageAddressTableLookup struct { - state protoimpl.MessageState `protogen:"open.v1"` - AccountKey []byte `protobuf:"bytes,1,opt,name=account_key,json=accountKey,proto3" json:"account_key,omitempty"` - WritableIndexes []byte `protobuf:"bytes,2,opt,name=writable_indexes,json=writableIndexes,proto3" json:"writable_indexes,omitempty"` - ReadonlyIndexes []byte `protobuf:"bytes,3,opt,name=readonly_indexes,json=readonlyIndexes,proto3" json:"readonly_indexes,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *MessageAddressTableLookup) Reset() { - *x = MessageAddressTableLookup{} - mi := &file_solana_storage_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *MessageAddressTableLookup) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*MessageAddressTableLookup) ProtoMessage() {} - -func (x *MessageAddressTableLookup) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[5] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use MessageAddressTableLookup.ProtoReflect.Descriptor instead. -func (*MessageAddressTableLookup) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{5} -} - -func (x *MessageAddressTableLookup) GetAccountKey() []byte { - if x != nil { - return x.AccountKey - } - return nil -} - -func (x *MessageAddressTableLookup) GetWritableIndexes() []byte { - if x != nil { - return x.WritableIndexes - } - return nil -} - -func (x *MessageAddressTableLookup) GetReadonlyIndexes() []byte { - if x != nil { - return x.ReadonlyIndexes - } - return nil -} - -type TransactionStatusMeta struct { - state protoimpl.MessageState `protogen:"open.v1"` - Err *TransactionError `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"` - Fee uint64 `protobuf:"varint,2,opt,name=fee,proto3" json:"fee,omitempty"` - PreBalances []uint64 `protobuf:"varint,3,rep,packed,name=pre_balances,json=preBalances,proto3" json:"pre_balances,omitempty"` - PostBalances []uint64 `protobuf:"varint,4,rep,packed,name=post_balances,json=postBalances,proto3" json:"post_balances,omitempty"` - InnerInstructions []*InnerInstructions `protobuf:"bytes,5,rep,name=inner_instructions,json=innerInstructions,proto3" json:"inner_instructions,omitempty"` - InnerInstructionsNone bool `protobuf:"varint,10,opt,name=inner_instructions_none,json=innerInstructionsNone,proto3" json:"inner_instructions_none,omitempty"` - LogMessages []string `protobuf:"bytes,6,rep,name=log_messages,json=logMessages,proto3" json:"log_messages,omitempty"` - LogMessagesNone bool `protobuf:"varint,11,opt,name=log_messages_none,json=logMessagesNone,proto3" json:"log_messages_none,omitempty"` - PreTokenBalances []*TokenBalance `protobuf:"bytes,7,rep,name=pre_token_balances,json=preTokenBalances,proto3" json:"pre_token_balances,omitempty"` - PostTokenBalances []*TokenBalance `protobuf:"bytes,8,rep,name=post_token_balances,json=postTokenBalances,proto3" json:"post_token_balances,omitempty"` - Rewards []*Reward `protobuf:"bytes,9,rep,name=rewards,proto3" json:"rewards,omitempty"` - LoadedWritableAddresses [][]byte `protobuf:"bytes,12,rep,name=loaded_writable_addresses,json=loadedWritableAddresses,proto3" json:"loaded_writable_addresses,omitempty"` - LoadedReadonlyAddresses [][]byte `protobuf:"bytes,13,rep,name=loaded_readonly_addresses,json=loadedReadonlyAddresses,proto3" json:"loaded_readonly_addresses,omitempty"` - ReturnData *ReturnData `protobuf:"bytes,14,opt,name=return_data,json=returnData,proto3" json:"return_data,omitempty"` - ReturnDataNone bool `protobuf:"varint,15,opt,name=return_data_none,json=returnDataNone,proto3" json:"return_data_none,omitempty"` - // Sum of compute units consumed by all instructions. - // Available since Solana v1.10.35 / v1.11.6. - // Set to `None` for txs executed on earlier versions. - ComputeUnitsConsumed *uint64 `protobuf:"varint,16,opt,name=compute_units_consumed,json=computeUnitsConsumed,proto3,oneof" json:"compute_units_consumed,omitempty"` - // Total transaction cost - CostUnits *uint64 `protobuf:"varint,17,opt,name=cost_units,json=costUnits,proto3,oneof" json:"cost_units,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *TransactionStatusMeta) Reset() { - *x = TransactionStatusMeta{} - mi := &file_solana_storage_proto_msgTypes[6] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *TransactionStatusMeta) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*TransactionStatusMeta) ProtoMessage() {} - -func (x *TransactionStatusMeta) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[6] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use TransactionStatusMeta.ProtoReflect.Descriptor instead. -func (*TransactionStatusMeta) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{6} -} - -func (x *TransactionStatusMeta) GetErr() *TransactionError { - if x != nil { - return x.Err - } - return nil -} - -func (x *TransactionStatusMeta) GetFee() uint64 { - if x != nil { - return x.Fee - } - return 0 -} - -func (x *TransactionStatusMeta) GetPreBalances() []uint64 { - if x != nil { - return x.PreBalances - } - return nil -} - -func (x *TransactionStatusMeta) GetPostBalances() []uint64 { - if x != nil { - return x.PostBalances - } - return nil -} - -func (x *TransactionStatusMeta) GetInnerInstructions() []*InnerInstructions { - if x != nil { - return x.InnerInstructions - } - return nil -} - -func (x *TransactionStatusMeta) GetInnerInstructionsNone() bool { - if x != nil { - return x.InnerInstructionsNone - } - return false -} - -func (x *TransactionStatusMeta) GetLogMessages() []string { - if x != nil { - return x.LogMessages - } - return nil -} - -func (x *TransactionStatusMeta) GetLogMessagesNone() bool { - if x != nil { - return x.LogMessagesNone - } - return false -} - -func (x *TransactionStatusMeta) GetPreTokenBalances() []*TokenBalance { - if x != nil { - return x.PreTokenBalances - } - return nil -} - -func (x *TransactionStatusMeta) GetPostTokenBalances() []*TokenBalance { - if x != nil { - return x.PostTokenBalances - } - return nil -} - -func (x *TransactionStatusMeta) GetRewards() []*Reward { - if x != nil { - return x.Rewards - } - return nil -} - -func (x *TransactionStatusMeta) GetLoadedWritableAddresses() [][]byte { - if x != nil { - return x.LoadedWritableAddresses - } - return nil -} - -func (x *TransactionStatusMeta) GetLoadedReadonlyAddresses() [][]byte { - if x != nil { - return x.LoadedReadonlyAddresses - } - return nil -} - -func (x *TransactionStatusMeta) GetReturnData() *ReturnData { - if x != nil { - return x.ReturnData - } - return nil -} - -func (x *TransactionStatusMeta) GetReturnDataNone() bool { - if x != nil { - return x.ReturnDataNone - } - return false -} - -func (x *TransactionStatusMeta) GetComputeUnitsConsumed() uint64 { - if x != nil && x.ComputeUnitsConsumed != nil { - return *x.ComputeUnitsConsumed - } - return 0 -} - -func (x *TransactionStatusMeta) GetCostUnits() uint64 { - if x != nil && x.CostUnits != nil { - return *x.CostUnits - } - return 0 -} - -type TransactionError struct { - state protoimpl.MessageState `protogen:"open.v1"` - Err []byte `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *TransactionError) Reset() { - *x = TransactionError{} - mi := &file_solana_storage_proto_msgTypes[7] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *TransactionError) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*TransactionError) ProtoMessage() {} - -func (x *TransactionError) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[7] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use TransactionError.ProtoReflect.Descriptor instead. -func (*TransactionError) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{7} -} - -func (x *TransactionError) GetErr() []byte { - if x != nil { - return x.Err - } - return nil -} - -type InnerInstructions struct { - state protoimpl.MessageState `protogen:"open.v1"` - Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` - Instructions []*InnerInstruction `protobuf:"bytes,2,rep,name=instructions,proto3" json:"instructions,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *InnerInstructions) Reset() { - *x = InnerInstructions{} - mi := &file_solana_storage_proto_msgTypes[8] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *InnerInstructions) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*InnerInstructions) ProtoMessage() {} - -func (x *InnerInstructions) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[8] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use InnerInstructions.ProtoReflect.Descriptor instead. -func (*InnerInstructions) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{8} -} - -func (x *InnerInstructions) GetIndex() uint32 { - if x != nil { - return x.Index - } - return 0 -} - -func (x *InnerInstructions) GetInstructions() []*InnerInstruction { - if x != nil { - return x.Instructions - } - return nil -} - -type InnerInstruction struct { - state protoimpl.MessageState `protogen:"open.v1"` - ProgramIdIndex uint32 `protobuf:"varint,1,opt,name=program_id_index,json=programIdIndex,proto3" json:"program_id_index,omitempty"` - Accounts []byte `protobuf:"bytes,2,opt,name=accounts,proto3" json:"accounts,omitempty"` - Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` - // Invocation stack height of an inner instruction. - // Available since Solana v1.14.6 - // Set to `None` for txs executed on earlier versions. - StackHeight *uint32 `protobuf:"varint,4,opt,name=stack_height,json=stackHeight,proto3,oneof" json:"stack_height,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *InnerInstruction) Reset() { - *x = InnerInstruction{} - mi := &file_solana_storage_proto_msgTypes[9] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *InnerInstruction) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*InnerInstruction) ProtoMessage() {} - -func (x *InnerInstruction) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[9] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use InnerInstruction.ProtoReflect.Descriptor instead. -func (*InnerInstruction) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{9} -} - -func (x *InnerInstruction) GetProgramIdIndex() uint32 { - if x != nil { - return x.ProgramIdIndex - } - return 0 -} - -func (x *InnerInstruction) GetAccounts() []byte { - if x != nil { - return x.Accounts - } - return nil -} - -func (x *InnerInstruction) GetData() []byte { - if x != nil { - return x.Data - } - return nil -} - -func (x *InnerInstruction) GetStackHeight() uint32 { - if x != nil && x.StackHeight != nil { - return *x.StackHeight - } - return 0 -} - -type CompiledInstruction struct { - state protoimpl.MessageState `protogen:"open.v1"` - ProgramIdIndex uint32 `protobuf:"varint,1,opt,name=program_id_index,json=programIdIndex,proto3" json:"program_id_index,omitempty"` - Accounts []byte `protobuf:"bytes,2,opt,name=accounts,proto3" json:"accounts,omitempty"` - Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *CompiledInstruction) Reset() { - *x = CompiledInstruction{} - mi := &file_solana_storage_proto_msgTypes[10] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *CompiledInstruction) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CompiledInstruction) ProtoMessage() {} - -func (x *CompiledInstruction) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[10] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use CompiledInstruction.ProtoReflect.Descriptor instead. -func (*CompiledInstruction) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{10} -} - -func (x *CompiledInstruction) GetProgramIdIndex() uint32 { - if x != nil { - return x.ProgramIdIndex - } - return 0 -} - -func (x *CompiledInstruction) GetAccounts() []byte { - if x != nil { - return x.Accounts - } - return nil -} - -func (x *CompiledInstruction) GetData() []byte { - if x != nil { - return x.Data - } - return nil -} - -type TokenBalance struct { - state protoimpl.MessageState `protogen:"open.v1"` - AccountIndex uint32 `protobuf:"varint,1,opt,name=account_index,json=accountIndex,proto3" json:"account_index,omitempty"` - Mint string `protobuf:"bytes,2,opt,name=mint,proto3" json:"mint,omitempty"` - UiTokenAmount *UiTokenAmount `protobuf:"bytes,3,opt,name=ui_token_amount,json=uiTokenAmount,proto3" json:"ui_token_amount,omitempty"` - Owner string `protobuf:"bytes,4,opt,name=owner,proto3" json:"owner,omitempty"` - ProgramId string `protobuf:"bytes,5,opt,name=program_id,json=programId,proto3" json:"program_id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *TokenBalance) Reset() { - *x = TokenBalance{} - mi := &file_solana_storage_proto_msgTypes[11] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *TokenBalance) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*TokenBalance) ProtoMessage() {} - -func (x *TokenBalance) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[11] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use TokenBalance.ProtoReflect.Descriptor instead. -func (*TokenBalance) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{11} -} - -func (x *TokenBalance) GetAccountIndex() uint32 { - if x != nil { - return x.AccountIndex - } - return 0 -} - -func (x *TokenBalance) GetMint() string { - if x != nil { - return x.Mint - } - return "" -} - -func (x *TokenBalance) GetUiTokenAmount() *UiTokenAmount { - if x != nil { - return x.UiTokenAmount - } - return nil -} - -func (x *TokenBalance) GetOwner() string { - if x != nil { - return x.Owner - } - return "" -} - -func (x *TokenBalance) GetProgramId() string { - if x != nil { - return x.ProgramId - } - return "" -} - -type UiTokenAmount struct { - state protoimpl.MessageState `protogen:"open.v1"` - UiAmount float64 `protobuf:"fixed64,1,opt,name=ui_amount,json=uiAmount,proto3" json:"ui_amount,omitempty"` - Decimals uint32 `protobuf:"varint,2,opt,name=decimals,proto3" json:"decimals,omitempty"` - Amount string `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"` - UiAmountString string `protobuf:"bytes,4,opt,name=ui_amount_string,json=uiAmountString,proto3" json:"ui_amount_string,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *UiTokenAmount) Reset() { - *x = UiTokenAmount{} - mi := &file_solana_storage_proto_msgTypes[12] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *UiTokenAmount) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*UiTokenAmount) ProtoMessage() {} - -func (x *UiTokenAmount) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[12] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use UiTokenAmount.ProtoReflect.Descriptor instead. -func (*UiTokenAmount) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{12} -} - -func (x *UiTokenAmount) GetUiAmount() float64 { - if x != nil { - return x.UiAmount - } - return 0 -} - -func (x *UiTokenAmount) GetDecimals() uint32 { - if x != nil { - return x.Decimals - } - return 0 -} - -func (x *UiTokenAmount) GetAmount() string { - if x != nil { - return x.Amount - } - return "" -} - -func (x *UiTokenAmount) GetUiAmountString() string { - if x != nil { - return x.UiAmountString - } - return "" -} - -type ReturnData struct { - state protoimpl.MessageState `protogen:"open.v1"` - ProgramId []byte `protobuf:"bytes,1,opt,name=program_id,json=programId,proto3" json:"program_id,omitempty"` - Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ReturnData) Reset() { - *x = ReturnData{} - mi := &file_solana_storage_proto_msgTypes[13] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ReturnData) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ReturnData) ProtoMessage() {} - -func (x *ReturnData) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[13] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use ReturnData.ProtoReflect.Descriptor instead. -func (*ReturnData) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{13} -} - -func (x *ReturnData) GetProgramId() []byte { - if x != nil { - return x.ProgramId - } - return nil -} - -func (x *ReturnData) GetData() []byte { - if x != nil { - return x.Data - } - return nil -} - -type Reward struct { - state protoimpl.MessageState `protogen:"open.v1"` - Pubkey string `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"` - Lamports int64 `protobuf:"varint,2,opt,name=lamports,proto3" json:"lamports,omitempty"` - PostBalance uint64 `protobuf:"varint,3,opt,name=post_balance,json=postBalance,proto3" json:"post_balance,omitempty"` - RewardType RewardType `protobuf:"varint,4,opt,name=reward_type,json=rewardType,proto3,enum=solana.storage.ConfirmedBlock.RewardType" json:"reward_type,omitempty"` - Commission string `protobuf:"bytes,5,opt,name=commission,proto3" json:"commission,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *Reward) Reset() { - *x = Reward{} - mi := &file_solana_storage_proto_msgTypes[14] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *Reward) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Reward) ProtoMessage() {} - -func (x *Reward) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[14] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Reward.ProtoReflect.Descriptor instead. -func (*Reward) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{14} -} - -func (x *Reward) GetPubkey() string { - if x != nil { - return x.Pubkey - } - return "" -} - -func (x *Reward) GetLamports() int64 { - if x != nil { - return x.Lamports - } - return 0 -} - -func (x *Reward) GetPostBalance() uint64 { - if x != nil { - return x.PostBalance - } - return 0 -} - -func (x *Reward) GetRewardType() RewardType { - if x != nil { - return x.RewardType - } - return RewardType_Unspecified -} - -func (x *Reward) GetCommission() string { - if x != nil { - return x.Commission - } - return "" -} - -type Rewards struct { - state protoimpl.MessageState `protogen:"open.v1"` - Rewards []*Reward `protobuf:"bytes,1,rep,name=rewards,proto3" json:"rewards,omitempty"` - NumPartitions *NumPartitions `protobuf:"bytes,2,opt,name=num_partitions,json=numPartitions,proto3" json:"num_partitions,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *Rewards) Reset() { - *x = Rewards{} - mi := &file_solana_storage_proto_msgTypes[15] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *Rewards) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Rewards) ProtoMessage() {} - -func (x *Rewards) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[15] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Rewards.ProtoReflect.Descriptor instead. -func (*Rewards) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{15} -} - -func (x *Rewards) GetRewards() []*Reward { - if x != nil { - return x.Rewards - } - return nil -} - -func (x *Rewards) GetNumPartitions() *NumPartitions { - if x != nil { - return x.NumPartitions - } - return nil -} - -type UnixTimestamp struct { - state protoimpl.MessageState `protogen:"open.v1"` - Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *UnixTimestamp) Reset() { - *x = UnixTimestamp{} - mi := &file_solana_storage_proto_msgTypes[16] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *UnixTimestamp) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*UnixTimestamp) ProtoMessage() {} - -func (x *UnixTimestamp) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[16] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use UnixTimestamp.ProtoReflect.Descriptor instead. -func (*UnixTimestamp) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{16} -} - -func (x *UnixTimestamp) GetTimestamp() int64 { - if x != nil { - return x.Timestamp - } - return 0 -} - -type BlockHeight struct { - state protoimpl.MessageState `protogen:"open.v1"` - BlockHeight uint64 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *BlockHeight) Reset() { - *x = BlockHeight{} - mi := &file_solana_storage_proto_msgTypes[17] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *BlockHeight) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*BlockHeight) ProtoMessage() {} - -func (x *BlockHeight) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[17] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use BlockHeight.ProtoReflect.Descriptor instead. -func (*BlockHeight) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{17} -} - -func (x *BlockHeight) GetBlockHeight() uint64 { - if x != nil { - return x.BlockHeight - } - return 0 -} - -type NumPartitions struct { - state protoimpl.MessageState `protogen:"open.v1"` - NumPartitions uint64 `protobuf:"varint,1,opt,name=num_partitions,json=numPartitions,proto3" json:"num_partitions,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *NumPartitions) Reset() { - *x = NumPartitions{} - mi := &file_solana_storage_proto_msgTypes[18] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *NumPartitions) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*NumPartitions) ProtoMessage() {} - -func (x *NumPartitions) ProtoReflect() protoreflect.Message { - mi := &file_solana_storage_proto_msgTypes[18] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use NumPartitions.ProtoReflect.Descriptor instead. -func (*NumPartitions) Descriptor() ([]byte, []int) { - return file_solana_storage_proto_rawDescGZIP(), []int{18} -} - -func (x *NumPartitions) GetNumPartitions() uint64 { - if x != nil { - return x.NumPartitions - } - return 0 -} - -var File_solana_storage_proto protoreflect.FileDescriptor - -const file_solana_storage_proto_rawDesc = "" + - "\n" + - "\x14solana-storage.proto\x12\x1dsolana.storage.ConfirmedBlock\"\x89\x04\n" + - "\x0eConfirmedBlock\x12-\n" + - "\x12previous_blockhash\x18\x01 \x01(\tR\x11previousBlockhash\x12\x1c\n" + - "\tblockhash\x18\x02 \x01(\tR\tblockhash\x12\x1f\n" + - "\vparent_slot\x18\x03 \x01(\x04R\n" + - "parentSlot\x12W\n" + - "\ftransactions\x18\x04 \x03(\v23.solana.storage.ConfirmedBlock.ConfirmedTransactionR\ftransactions\x12?\n" + - "\arewards\x18\x05 \x03(\v2%.solana.storage.ConfirmedBlock.RewardR\arewards\x12K\n" + - "\n" + - "block_time\x18\x06 \x01(\v2,.solana.storage.ConfirmedBlock.UnixTimestampR\tblockTime\x12M\n" + - "\fblock_height\x18\a \x01(\v2*.solana.storage.ConfirmedBlock.BlockHeightR\vblockHeight\x12S\n" + - "\x0enum_partitions\x18\b \x01(\v2,.solana.storage.ConfirmedBlock.NumPartitionsR\rnumPartitions\"\xae\x01\n" + - "\x14ConfirmedTransaction\x12L\n" + - "\vtransaction\x18\x01 \x01(\v2*.solana.storage.ConfirmedBlock.TransactionR\vtransaction\x12H\n" + - "\x04meta\x18\x02 \x01(\v24.solana.storage.ConfirmedBlock.TransactionStatusMetaR\x04meta\"o\n" + - "\vTransaction\x12\x1e\n" + - "\n" + - "signatures\x18\x01 \x03(\fR\n" + - "signatures\x12@\n" + - "\amessage\x18\x02 \x01(\v2&.solana.storage.ConfirmedBlock.MessageR\amessage\"\x81\x03\n" + - "\aMessage\x12D\n" + - "\x06header\x18\x01 \x01(\v2,.solana.storage.ConfirmedBlock.MessageHeaderR\x06header\x12!\n" + - "\faccount_keys\x18\x02 \x03(\fR\vaccountKeys\x12)\n" + - "\x10recent_blockhash\x18\x03 \x01(\fR\x0frecentBlockhash\x12V\n" + - "\finstructions\x18\x04 \x03(\v22.solana.storage.ConfirmedBlock.CompiledInstructionR\finstructions\x12\x1c\n" + - "\tversioned\x18\x05 \x01(\bR\tversioned\x12l\n" + - "\x15address_table_lookups\x18\x06 \x03(\v28.solana.storage.ConfirmedBlock.MessageAddressTableLookupR\x13addressTableLookups\"\xcd\x01\n" + - "\rMessageHeader\x126\n" + - "\x17num_required_signatures\x18\x01 \x01(\rR\x15numRequiredSignatures\x12?\n" + - "\x1cnum_readonly_signed_accounts\x18\x02 \x01(\rR\x19numReadonlySignedAccounts\x12C\n" + - "\x1enum_readonly_unsigned_accounts\x18\x03 \x01(\rR\x1bnumReadonlyUnsignedAccounts\"\x92\x01\n" + - "\x19MessageAddressTableLookup\x12\x1f\n" + - "\vaccount_key\x18\x01 \x01(\fR\n" + - "accountKey\x12)\n" + - "\x10writable_indexes\x18\x02 \x01(\fR\x0fwritableIndexes\x12)\n" + - "\x10readonly_indexes\x18\x03 \x01(\fR\x0freadonlyIndexes\"\x8c\b\n" + - "\x15TransactionStatusMeta\x12A\n" + - "\x03err\x18\x01 \x01(\v2/.solana.storage.ConfirmedBlock.TransactionErrorR\x03err\x12\x10\n" + - "\x03fee\x18\x02 \x01(\x04R\x03fee\x12!\n" + - "\fpre_balances\x18\x03 \x03(\x04R\vpreBalances\x12#\n" + - "\rpost_balances\x18\x04 \x03(\x04R\fpostBalances\x12_\n" + - "\x12inner_instructions\x18\x05 \x03(\v20.solana.storage.ConfirmedBlock.InnerInstructionsR\x11innerInstructions\x126\n" + - "\x17inner_instructions_none\x18\n" + - " \x01(\bR\x15innerInstructionsNone\x12!\n" + - "\flog_messages\x18\x06 \x03(\tR\vlogMessages\x12*\n" + - "\x11log_messages_none\x18\v \x01(\bR\x0flogMessagesNone\x12Y\n" + - "\x12pre_token_balances\x18\a \x03(\v2+.solana.storage.ConfirmedBlock.TokenBalanceR\x10preTokenBalances\x12[\n" + - "\x13post_token_balances\x18\b \x03(\v2+.solana.storage.ConfirmedBlock.TokenBalanceR\x11postTokenBalances\x12?\n" + - "\arewards\x18\t \x03(\v2%.solana.storage.ConfirmedBlock.RewardR\arewards\x12:\n" + - "\x19loaded_writable_addresses\x18\f \x03(\fR\x17loadedWritableAddresses\x12:\n" + - "\x19loaded_readonly_addresses\x18\r \x03(\fR\x17loadedReadonlyAddresses\x12J\n" + - "\vreturn_data\x18\x0e \x01(\v2).solana.storage.ConfirmedBlock.ReturnDataR\n" + - "returnData\x12(\n" + - "\x10return_data_none\x18\x0f \x01(\bR\x0ereturnDataNone\x129\n" + - "\x16compute_units_consumed\x18\x10 \x01(\x04H\x00R\x14computeUnitsConsumed\x88\x01\x01\x12\"\n" + - "\n" + - "cost_units\x18\x11 \x01(\x04H\x01R\tcostUnits\x88\x01\x01B\x19\n" + - "\x17_compute_units_consumedB\r\n" + - "\v_cost_units\"$\n" + - "\x10TransactionError\x12\x10\n" + - "\x03err\x18\x01 \x01(\fR\x03err\"~\n" + - "\x11InnerInstructions\x12\x14\n" + - "\x05index\x18\x01 \x01(\rR\x05index\x12S\n" + - "\finstructions\x18\x02 \x03(\v2/.solana.storage.ConfirmedBlock.InnerInstructionR\finstructions\"\xa5\x01\n" + - "\x10InnerInstruction\x12(\n" + - "\x10program_id_index\x18\x01 \x01(\rR\x0eprogramIdIndex\x12\x1a\n" + - "\baccounts\x18\x02 \x01(\fR\baccounts\x12\x12\n" + - "\x04data\x18\x03 \x01(\fR\x04data\x12&\n" + - "\fstack_height\x18\x04 \x01(\rH\x00R\vstackHeight\x88\x01\x01B\x0f\n" + - "\r_stack_height\"o\n" + - "\x13CompiledInstruction\x12(\n" + - "\x10program_id_index\x18\x01 \x01(\rR\x0eprogramIdIndex\x12\x1a\n" + - "\baccounts\x18\x02 \x01(\fR\baccounts\x12\x12\n" + - "\x04data\x18\x03 \x01(\fR\x04data\"\xd2\x01\n" + - "\fTokenBalance\x12#\n" + - "\raccount_index\x18\x01 \x01(\rR\faccountIndex\x12\x12\n" + - "\x04mint\x18\x02 \x01(\tR\x04mint\x12T\n" + - "\x0fui_token_amount\x18\x03 \x01(\v2,.solana.storage.ConfirmedBlock.UiTokenAmountR\ruiTokenAmount\x12\x14\n" + - "\x05owner\x18\x04 \x01(\tR\x05owner\x12\x1d\n" + - "\n" + - "program_id\x18\x05 \x01(\tR\tprogramId\"\x8a\x01\n" + - "\rUiTokenAmount\x12\x1b\n" + - "\tui_amount\x18\x01 \x01(\x01R\buiAmount\x12\x1a\n" + - "\bdecimals\x18\x02 \x01(\rR\bdecimals\x12\x16\n" + - "\x06amount\x18\x03 \x01(\tR\x06amount\x12(\n" + - "\x10ui_amount_string\x18\x04 \x01(\tR\x0euiAmountString\"?\n" + - "\n" + - "ReturnData\x12\x1d\n" + - "\n" + - "program_id\x18\x01 \x01(\fR\tprogramId\x12\x12\n" + - "\x04data\x18\x02 \x01(\fR\x04data\"\xcb\x01\n" + - "\x06Reward\x12\x16\n" + - "\x06pubkey\x18\x01 \x01(\tR\x06pubkey\x12\x1a\n" + - "\blamports\x18\x02 \x01(\x03R\blamports\x12!\n" + - "\fpost_balance\x18\x03 \x01(\x04R\vpostBalance\x12J\n" + - "\vreward_type\x18\x04 \x01(\x0e2).solana.storage.ConfirmedBlock.RewardTypeR\n" + - "rewardType\x12\x1e\n" + - "\n" + - "commission\x18\x05 \x01(\tR\n" + - "commission\"\x9f\x01\n" + - "\aRewards\x12?\n" + - "\arewards\x18\x01 \x03(\v2%.solana.storage.ConfirmedBlock.RewardR\arewards\x12S\n" + - "\x0enum_partitions\x18\x02 \x01(\v2,.solana.storage.ConfirmedBlock.NumPartitionsR\rnumPartitions\"-\n" + - "\rUnixTimestamp\x12\x1c\n" + - "\ttimestamp\x18\x01 \x01(\x03R\ttimestamp\"0\n" + - "\vBlockHeight\x12!\n" + - "\fblock_height\x18\x01 \x01(\x04R\vblockHeight\"6\n" + - "\rNumPartitions\x12%\n" + - "\x0enum_partitions\x18\x01 \x01(\x04R\rnumPartitions*I\n" + - "\n" + - "RewardType\x12\x0f\n" + - "\vUnspecified\x10\x00\x12\a\n" + - "\x03Fee\x10\x01\x12\b\n" + - "\x04Rent\x10\x02\x12\v\n" + - "\aStaking\x10\x03\x12\n" + - "\n" + - "\x06Voting\x10\x04B4Z2github.com/Overclock-Validator/mithril/pkg/grpc/pbb\x06proto3" - -var ( - file_solana_storage_proto_rawDescOnce sync.Once - file_solana_storage_proto_rawDescData []byte -) - -func file_solana_storage_proto_rawDescGZIP() []byte { - file_solana_storage_proto_rawDescOnce.Do(func() { - file_solana_storage_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_solana_storage_proto_rawDesc), len(file_solana_storage_proto_rawDesc))) - }) - return file_solana_storage_proto_rawDescData -} - -var file_solana_storage_proto_enumTypes = make([]protoimpl.EnumInfo, 1) -var file_solana_storage_proto_msgTypes = make([]protoimpl.MessageInfo, 19) -var file_solana_storage_proto_goTypes = []any{ - (RewardType)(0), // 0: solana.storage.ConfirmedBlock.RewardType - (*ConfirmedBlock)(nil), // 1: solana.storage.ConfirmedBlock.ConfirmedBlock - (*ConfirmedTransaction)(nil), // 2: solana.storage.ConfirmedBlock.ConfirmedTransaction - (*Transaction)(nil), // 3: solana.storage.ConfirmedBlock.Transaction - (*Message)(nil), // 4: solana.storage.ConfirmedBlock.Message - (*MessageHeader)(nil), // 5: solana.storage.ConfirmedBlock.MessageHeader - (*MessageAddressTableLookup)(nil), // 6: solana.storage.ConfirmedBlock.MessageAddressTableLookup - (*TransactionStatusMeta)(nil), // 7: solana.storage.ConfirmedBlock.TransactionStatusMeta - (*TransactionError)(nil), // 8: solana.storage.ConfirmedBlock.TransactionError - (*InnerInstructions)(nil), // 9: solana.storage.ConfirmedBlock.InnerInstructions - (*InnerInstruction)(nil), // 10: solana.storage.ConfirmedBlock.InnerInstruction - (*CompiledInstruction)(nil), // 11: solana.storage.ConfirmedBlock.CompiledInstruction - (*TokenBalance)(nil), // 12: solana.storage.ConfirmedBlock.TokenBalance - (*UiTokenAmount)(nil), // 13: solana.storage.ConfirmedBlock.UiTokenAmount - (*ReturnData)(nil), // 14: solana.storage.ConfirmedBlock.ReturnData - (*Reward)(nil), // 15: solana.storage.ConfirmedBlock.Reward - (*Rewards)(nil), // 16: solana.storage.ConfirmedBlock.Rewards - (*UnixTimestamp)(nil), // 17: solana.storage.ConfirmedBlock.UnixTimestamp - (*BlockHeight)(nil), // 18: solana.storage.ConfirmedBlock.BlockHeight - (*NumPartitions)(nil), // 19: solana.storage.ConfirmedBlock.NumPartitions -} -var file_solana_storage_proto_depIdxs = []int32{ - 2, // 0: solana.storage.ConfirmedBlock.ConfirmedBlock.transactions:type_name -> solana.storage.ConfirmedBlock.ConfirmedTransaction - 15, // 1: solana.storage.ConfirmedBlock.ConfirmedBlock.rewards:type_name -> solana.storage.ConfirmedBlock.Reward - 17, // 2: solana.storage.ConfirmedBlock.ConfirmedBlock.block_time:type_name -> solana.storage.ConfirmedBlock.UnixTimestamp - 18, // 3: solana.storage.ConfirmedBlock.ConfirmedBlock.block_height:type_name -> solana.storage.ConfirmedBlock.BlockHeight - 19, // 4: solana.storage.ConfirmedBlock.ConfirmedBlock.num_partitions:type_name -> solana.storage.ConfirmedBlock.NumPartitions - 3, // 5: solana.storage.ConfirmedBlock.ConfirmedTransaction.transaction:type_name -> solana.storage.ConfirmedBlock.Transaction - 7, // 6: solana.storage.ConfirmedBlock.ConfirmedTransaction.meta:type_name -> solana.storage.ConfirmedBlock.TransactionStatusMeta - 4, // 7: solana.storage.ConfirmedBlock.Transaction.message:type_name -> solana.storage.ConfirmedBlock.Message - 5, // 8: solana.storage.ConfirmedBlock.Message.header:type_name -> solana.storage.ConfirmedBlock.MessageHeader - 11, // 9: solana.storage.ConfirmedBlock.Message.instructions:type_name -> solana.storage.ConfirmedBlock.CompiledInstruction - 6, // 10: solana.storage.ConfirmedBlock.Message.address_table_lookups:type_name -> solana.storage.ConfirmedBlock.MessageAddressTableLookup - 8, // 11: solana.storage.ConfirmedBlock.TransactionStatusMeta.err:type_name -> solana.storage.ConfirmedBlock.TransactionError - 9, // 12: solana.storage.ConfirmedBlock.TransactionStatusMeta.inner_instructions:type_name -> solana.storage.ConfirmedBlock.InnerInstructions - 12, // 13: solana.storage.ConfirmedBlock.TransactionStatusMeta.pre_token_balances:type_name -> solana.storage.ConfirmedBlock.TokenBalance - 12, // 14: solana.storage.ConfirmedBlock.TransactionStatusMeta.post_token_balances:type_name -> solana.storage.ConfirmedBlock.TokenBalance - 15, // 15: solana.storage.ConfirmedBlock.TransactionStatusMeta.rewards:type_name -> solana.storage.ConfirmedBlock.Reward - 14, // 16: solana.storage.ConfirmedBlock.TransactionStatusMeta.return_data:type_name -> solana.storage.ConfirmedBlock.ReturnData - 10, // 17: solana.storage.ConfirmedBlock.InnerInstructions.instructions:type_name -> solana.storage.ConfirmedBlock.InnerInstruction - 13, // 18: solana.storage.ConfirmedBlock.TokenBalance.ui_token_amount:type_name -> solana.storage.ConfirmedBlock.UiTokenAmount - 0, // 19: solana.storage.ConfirmedBlock.Reward.reward_type:type_name -> solana.storage.ConfirmedBlock.RewardType - 15, // 20: solana.storage.ConfirmedBlock.Rewards.rewards:type_name -> solana.storage.ConfirmedBlock.Reward - 19, // 21: solana.storage.ConfirmedBlock.Rewards.num_partitions:type_name -> solana.storage.ConfirmedBlock.NumPartitions - 22, // [22:22] is the sub-list for method output_type - 22, // [22:22] is the sub-list for method input_type - 22, // [22:22] is the sub-list for extension type_name - 22, // [22:22] is the sub-list for extension extendee - 0, // [0:22] is the sub-list for field type_name -} - -func init() { file_solana_storage_proto_init() } -func file_solana_storage_proto_init() { - if File_solana_storage_proto != nil { - return - } - file_solana_storage_proto_msgTypes[6].OneofWrappers = []any{} - file_solana_storage_proto_msgTypes[9].OneofWrappers = []any{} - type x struct{} - out := protoimpl.TypeBuilder{ - File: protoimpl.DescBuilder{ - GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: unsafe.Slice(unsafe.StringData(file_solana_storage_proto_rawDesc), len(file_solana_storage_proto_rawDesc)), - NumEnums: 1, - NumMessages: 19, - NumExtensions: 0, - NumServices: 0, - }, - GoTypes: file_solana_storage_proto_goTypes, - DependencyIndexes: file_solana_storage_proto_depIdxs, - EnumInfos: file_solana_storage_proto_enumTypes, - MessageInfos: file_solana_storage_proto_msgTypes, - }.Build() - File_solana_storage_proto = out.File - file_solana_storage_proto_goTypes = nil - file_solana_storage_proto_depIdxs = nil -} diff --git a/pkg/grpc/pb/solana-storage.proto b/pkg/grpc/pb/solana-storage.proto deleted file mode 100644 index 9f285cc4..00000000 --- a/pkg/grpc/pb/solana-storage.proto +++ /dev/null @@ -1,151 +0,0 @@ -syntax = "proto3"; - -package solana.storage.ConfirmedBlock; - -option go_package = "github.com/Overclock-Validator/mithril/pkg/grpc/pb"; - -message ConfirmedBlock { - string previous_blockhash = 1; - string blockhash = 2; - uint64 parent_slot = 3; - repeated ConfirmedTransaction transactions = 4; - repeated Reward rewards = 5; - UnixTimestamp block_time = 6; - BlockHeight block_height = 7; - NumPartitions num_partitions = 8; -} - -message ConfirmedTransaction { - Transaction transaction = 1; - TransactionStatusMeta meta = 2; -} - -message Transaction { - repeated bytes signatures = 1; - Message message = 2; -} - -message Message { - MessageHeader header = 1; - repeated bytes account_keys = 2; - bytes recent_blockhash = 3; - repeated CompiledInstruction instructions = 4; - bool versioned = 5; - repeated MessageAddressTableLookup address_table_lookups = 6; -} - -message MessageHeader { - uint32 num_required_signatures = 1; - uint32 num_readonly_signed_accounts = 2; - uint32 num_readonly_unsigned_accounts = 3; -} - -message MessageAddressTableLookup { - bytes account_key = 1; - bytes writable_indexes = 2; - bytes readonly_indexes = 3; -} - -message TransactionStatusMeta { - TransactionError err = 1; - uint64 fee = 2; - repeated uint64 pre_balances = 3; - repeated uint64 post_balances = 4; - repeated InnerInstructions inner_instructions = 5; - bool inner_instructions_none = 10; - repeated string log_messages = 6; - bool log_messages_none = 11; - repeated TokenBalance pre_token_balances = 7; - repeated TokenBalance post_token_balances = 8; - repeated Reward rewards = 9; - repeated bytes loaded_writable_addresses = 12; - repeated bytes loaded_readonly_addresses = 13; - ReturnData return_data = 14; - bool return_data_none = 15; - - // Sum of compute units consumed by all instructions. - // Available since Solana v1.10.35 / v1.11.6. - // Set to `None` for txs executed on earlier versions. - optional uint64 compute_units_consumed = 16; - // Total transaction cost - optional uint64 cost_units = 17; -} - -message TransactionError { - bytes err = 1; -} - -message InnerInstructions { - uint32 index = 1; - repeated InnerInstruction instructions = 2; -} - -message InnerInstruction { - uint32 program_id_index = 1; - bytes accounts = 2; - bytes data = 3; - - // Invocation stack height of an inner instruction. - // Available since Solana v1.14.6 - // Set to `None` for txs executed on earlier versions. - optional uint32 stack_height = 4; -} - -message CompiledInstruction { - uint32 program_id_index = 1; - bytes accounts = 2; - bytes data = 3; -} - -message TokenBalance { - uint32 account_index = 1; - string mint = 2; - UiTokenAmount ui_token_amount = 3; - string owner = 4; - string program_id = 5; -} - -message UiTokenAmount { - double ui_amount = 1; - uint32 decimals = 2; - string amount = 3; - string ui_amount_string = 4; -} - -message ReturnData { - bytes program_id = 1; - bytes data = 2; -} - -enum RewardType { - Unspecified = 0; - Fee = 1; - Rent = 2; - Staking = 3; - Voting = 4; -} - -message Reward { - string pubkey = 1; - int64 lamports = 2; - uint64 post_balance = 3; - RewardType reward_type = 4; - string commission = 5; -} - -message Rewards { - repeated Reward rewards = 1; - NumPartitions num_partitions = 2; -} - -message UnixTimestamp { - int64 timestamp = 1; -} - -message BlockHeight { - uint64 block_height = 1; -} - -message NumPartitions { - uint64 num_partitions = 1; -}