// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v6.32.0
// source: solana/block_message.proto

package solana_messages

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_RewardTypeUnknown 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: "RewardTypeUnknown",
		1: "Fee",
		2: "Rent",
		3: "Staking",
		4: "Voting",
	}
	RewardType_value = map[string]int32{
		"RewardTypeUnknown": 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_block_message_proto_enumTypes[0].Descriptor()
}

func (RewardType) Type() protoreflect.EnumType {
	return &file_solana_block_message_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_block_message_proto_rawDescGZIP(), []int{0}
}

type Account struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Address       []byte                 `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
	IsSigner      bool                   `protobuf:"varint,2,opt,name=IsSigner,proto3" json:"IsSigner,omitempty"`
	IsWritable    bool                   `protobuf:"varint,3,opt,name=IsWritable,proto3" json:"IsWritable,omitempty"`
	Token         *TokenInfo             `protobuf:"bytes,4,opt,name=Token,proto3,oneof" json:"Token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Account) Reset() {
	*x = Account{}
	mi := &file_solana_block_message_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Account) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Account) ProtoMessage() {}

func (x *Account) ProtoReflect() protoreflect.Message {
	mi := &file_solana_block_message_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 Account.ProtoReflect.Descriptor instead.
func (*Account) Descriptor() ([]byte, []int) {
	return file_solana_block_message_proto_rawDescGZIP(), []int{0}
}

func (x *Account) GetAddress() []byte {
	if x != nil {
		return x.Address
	}
	return nil
}

func (x *Account) GetIsSigner() bool {
	if x != nil {
		return x.IsSigner
	}
	return false
}

func (x *Account) GetIsWritable() bool {
	if x != nil {
		return x.IsWritable
	}
	return false
}

func (x *Account) GetToken() *TokenInfo {
	if x != nil {
		return x.Token
	}
	return nil
}

type TokenInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Mint          []byte                 `protobuf:"bytes,1,opt,name=Mint,proto3" json:"Mint,omitempty"`
	Owner         []byte                 `protobuf:"bytes,2,opt,name=Owner,proto3" json:"Owner,omitempty"`
	Decimals      uint32                 `protobuf:"varint,3,opt,name=Decimals,proto3" json:"Decimals,omitempty"`
	ProgramId     []byte                 `protobuf:"bytes,4,opt,name=ProgramId,proto3" json:"ProgramId,omitempty"`
	Supply        uint64                 `protobuf:"varint,5,opt,name=Supply,proto3" json:"Supply,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TokenInfo) Reset() {
	*x = TokenInfo{}
	mi := &file_solana_block_message_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TokenInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TokenInfo) ProtoMessage() {}

func (x *TokenInfo) ProtoReflect() protoreflect.Message {
	mi := &file_solana_block_message_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 TokenInfo.ProtoReflect.Descriptor instead.
func (*TokenInfo) Descriptor() ([]byte, []int) {
	return file_solana_block_message_proto_rawDescGZIP(), []int{1}
}

func (x *TokenInfo) GetMint() []byte {
	if x != nil {
		return x.Mint
	}
	return nil
}

func (x *TokenInfo) GetOwner() []byte {
	if x != nil {
		return x.Owner
	}
	return nil
}

func (x *TokenInfo) GetDecimals() uint32 {
	if x != nil {
		return x.Decimals
	}
	return 0
}

func (x *TokenInfo) GetProgramId() []byte {
	if x != nil {
		return x.ProgramId
	}
	return nil
}

func (x *TokenInfo) GetSupply() uint64 {
	if x != nil {
		return x.Supply
	}
	return 0
}

type BalanceUpdate struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PreBalance    uint64                 `protobuf:"varint,1,opt,name=PreBalance,proto3" json:"PreBalance,omitempty"`
	PostBalance   uint64                 `protobuf:"varint,2,opt,name=PostBalance,proto3" json:"PostBalance,omitempty"`
	AccountIndex  uint32                 `protobuf:"varint,3,opt,name=AccountIndex,proto3" json:"AccountIndex,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BalanceUpdate) Reset() {
	*x = BalanceUpdate{}
	mi := &file_solana_block_message_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *BalanceUpdate) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*BalanceUpdate) ProtoMessage() {}

func (x *BalanceUpdate) ProtoReflect() protoreflect.Message {
	mi := &file_solana_block_message_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 BalanceUpdate.ProtoReflect.Descriptor instead.
func (*BalanceUpdate) Descriptor() ([]byte, []int) {
	return file_solana_block_message_proto_rawDescGZIP(), []int{2}
}

func (x *BalanceUpdate) GetPreBalance() uint64 {
	if x != nil {
		return x.PreBalance
	}
	return 0
}

func (x *BalanceUpdate) GetPostBalance() uint64 {
	if x != nil {
		return x.PostBalance
	}
	return 0
}

func (x *BalanceUpdate) GetAccountIndex() uint32 {
	if x != nil {
		return x.AccountIndex
	}
	return 0
}

type Instruction struct {
	state               protoimpl.MessageState `protogen:"open.v1"`
	ProgramAccountIndex uint32                 `protobuf:"varint,1,opt,name=ProgramAccountIndex,proto3" json:"ProgramAccountIndex,omitempty"`
	CallerIndex         uint64                 `protobuf:"varint,2,opt,name=CallerIndex,proto3" json:"CallerIndex,omitempty"`
	InnerIndex          uint64                 `protobuf:"varint,3,opt,name=InnerIndex,proto3" json:"InnerIndex,omitempty"`
	NestingLevel        uint64                 `protobuf:"varint,4,opt,name=NestingLevel,proto3" json:"NestingLevel,omitempty"`
	Data                []byte                 `protobuf:"bytes,5,opt,name=Data,proto3" json:"Data,omitempty"`
	AccountIndexes      []uint32               `protobuf:"varint,6,rep,packed,name=AccountIndexes,proto3" json:"AccountIndexes,omitempty"`
	BalanceUpdates      []*BalanceUpdate       `protobuf:"bytes,7,rep,name=BalanceUpdates,proto3" json:"BalanceUpdates,omitempty"`
	TokenBalanceUpdates []*BalanceUpdate       `protobuf:"bytes,8,rep,name=TokenBalanceUpdates,proto3" json:"TokenBalanceUpdates,omitempty"`
	TokenSupplyUpdates  []*BalanceUpdate       `protobuf:"bytes,9,rep,name=TokenSupplyUpdates,proto3" json:"TokenSupplyUpdates,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *Instruction) Reset() {
	*x = Instruction{}
	mi := &file_solana_block_message_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Instruction) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Instruction) ProtoMessage() {}

func (x *Instruction) ProtoReflect() protoreflect.Message {
	mi := &file_solana_block_message_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 Instruction.ProtoReflect.Descriptor instead.
func (*Instruction) Descriptor() ([]byte, []int) {
	return file_solana_block_message_proto_rawDescGZIP(), []int{3}
}

func (x *Instruction) GetProgramAccountIndex() uint32 {
	if x != nil {
		return x.ProgramAccountIndex
	}
	return 0
}

func (x *Instruction) GetCallerIndex() uint64 {
	if x != nil {
		return x.CallerIndex
	}
	return 0
}

func (x *Instruction) GetInnerIndex() uint64 {
	if x != nil {
		return x.InnerIndex
	}
	return 0
}

func (x *Instruction) GetNestingLevel() uint64 {
	if x != nil {
		return x.NestingLevel
	}
	return 0
}

func (x *Instruction) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

func (x *Instruction) GetAccountIndexes() []uint32 {
	if x != nil {
		return x.AccountIndexes
	}
	return nil
}

func (x *Instruction) GetBalanceUpdates() []*BalanceUpdate {
	if x != nil {
		return x.BalanceUpdates
	}
	return nil
}

func (x *Instruction) GetTokenBalanceUpdates() []*BalanceUpdate {
	if x != nil {
		return x.TokenBalanceUpdates
	}
	return nil
}

func (x *Instruction) GetTokenSupplyUpdates() []*BalanceUpdate {
	if x != nil {
		return x.TokenSupplyUpdates
	}
	return nil
}

type TransactionHeader struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	Fee             uint64                 `protobuf:"varint,1,opt,name=Fee,proto3" json:"Fee,omitempty"`
	FeePayer        []byte                 `protobuf:"bytes,2,opt,name=FeePayer,proto3" json:"FeePayer,omitempty"`
	RecentBlockhash []byte                 `protobuf:"bytes,3,opt,name=RecentBlockhash,proto3" json:"RecentBlockhash,omitempty"`
	Signer          []byte                 `protobuf:"bytes,4,opt,name=Signer,proto3" json:"Signer,omitempty"`
	Signatures      [][]byte               `protobuf:"bytes,5,rep,name=Signatures,proto3" json:"Signatures,omitempty"`
	Accounts        []*Account             `protobuf:"bytes,6,rep,name=Accounts,proto3" json:"Accounts,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *TransactionHeader) Reset() {
	*x = TransactionHeader{}
	mi := &file_solana_block_message_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TransactionHeader) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TransactionHeader) ProtoMessage() {}

func (x *TransactionHeader) ProtoReflect() protoreflect.Message {
	mi := &file_solana_block_message_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 TransactionHeader.ProtoReflect.Descriptor instead.
func (*TransactionHeader) Descriptor() ([]byte, []int) {
	return file_solana_block_message_proto_rawDescGZIP(), []int{4}
}

func (x *TransactionHeader) GetFee() uint64 {
	if x != nil {
		return x.Fee
	}
	return 0
}

func (x *TransactionHeader) GetFeePayer() []byte {
	if x != nil {
		return x.FeePayer
	}
	return nil
}

func (x *TransactionHeader) GetRecentBlockhash() []byte {
	if x != nil {
		return x.RecentBlockhash
	}
	return nil
}

func (x *TransactionHeader) GetSigner() []byte {
	if x != nil {
		return x.Signer
	}
	return nil
}

func (x *TransactionHeader) GetSignatures() [][]byte {
	if x != nil {
		return x.Signatures
	}
	return nil
}

func (x *TransactionHeader) GetAccounts() []*Account {
	if x != nil {
		return x.Accounts
	}
	return nil
}

type Reward struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Address       []byte                 `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
	Amount        int64                  `protobuf:"varint,2,opt,name=Amount,proto3" json:"Amount,omitempty"`
	PostBalance   uint64                 `protobuf:"varint,3,opt,name=PostBalance,proto3" json:"PostBalance,omitempty"`
	RewardType    RewardType             `protobuf:"varint,4,opt,name=RewardType,proto3,enum=solana_messages.RewardType" json:"RewardType,omitempty"`
	Commission    uint64                 `protobuf:"varint,5,opt,name=Commission,proto3" json:"Commission,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Reward) Reset() {
	*x = Reward{}
	mi := &file_solana_block_message_proto_msgTypes[5]
	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_block_message_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 Reward.ProtoReflect.Descriptor instead.
func (*Reward) Descriptor() ([]byte, []int) {
	return file_solana_block_message_proto_rawDescGZIP(), []int{5}
}

func (x *Reward) GetAddress() []byte {
	if x != nil {
		return x.Address
	}
	return nil
}

func (x *Reward) GetAmount() int64 {
	if x != nil {
		return x.Amount
	}
	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_RewardTypeUnknown
}

func (x *Reward) GetCommission() uint64 {
	if x != nil {
		return x.Commission
	}
	return 0
}

type TransactionStatus struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=Success,proto3" json:"Success,omitempty"`
	ErrorMessage  string                 `protobuf:"bytes,2,opt,name=ErrorMessage,proto3" json:"ErrorMessage,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TransactionStatus) Reset() {
	*x = TransactionStatus{}
	mi := &file_solana_block_message_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TransactionStatus) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TransactionStatus) ProtoMessage() {}

func (x *TransactionStatus) ProtoReflect() protoreflect.Message {
	mi := &file_solana_block_message_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 TransactionStatus.ProtoReflect.Descriptor instead.
func (*TransactionStatus) Descriptor() ([]byte, []int) {
	return file_solana_block_message_proto_rawDescGZIP(), []int{6}
}

func (x *TransactionStatus) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *TransactionStatus) GetErrorMessage() string {
	if x != nil {
		return x.ErrorMessage
	}
	return ""
}

type Transaction struct {
	state                    protoimpl.MessageState `protogen:"open.v1"`
	Signature                []byte                 `protobuf:"bytes,1,opt,name=Signature,proto3" json:"Signature,omitempty"`
	Status                   *TransactionStatus     `protobuf:"bytes,2,opt,name=Status,proto3" json:"Status,omitempty"`
	Header                   *TransactionHeader     `protobuf:"bytes,3,opt,name=Header,proto3" json:"Header,omitempty"`
	TotalBalanceUpdates      []*BalanceUpdate       `protobuf:"bytes,4,rep,name=TotalBalanceUpdates,proto3" json:"TotalBalanceUpdates,omitempty"`
	TotalTokenBalanceUpdates []*BalanceUpdate       `protobuf:"bytes,5,rep,name=TotalTokenBalanceUpdates,proto3" json:"TotalTokenBalanceUpdates,omitempty"`
	Instructions             []*Instruction         `protobuf:"bytes,7,rep,name=Instructions,proto3" json:"Instructions,omitempty"`
	Logs                     []string               `protobuf:"bytes,8,rep,name=Logs,proto3" json:"Logs,omitempty"`
	Index                    uint64                 `protobuf:"varint,9,opt,name=Index,proto3" json:"Index,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

func (x *Transaction) Reset() {
	*x = Transaction{}
	mi := &file_solana_block_message_proto_msgTypes[7]
	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_block_message_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 Transaction.ProtoReflect.Descriptor instead.
func (*Transaction) Descriptor() ([]byte, []int) {
	return file_solana_block_message_proto_rawDescGZIP(), []int{7}
}

func (x *Transaction) GetSignature() []byte {
	if x != nil {
		return x.Signature
	}
	return nil
}

func (x *Transaction) GetStatus() *TransactionStatus {
	if x != nil {
		return x.Status
	}
	return nil
}

func (x *Transaction) GetHeader() *TransactionHeader {
	if x != nil {
		return x.Header
	}
	return nil
}

func (x *Transaction) GetTotalBalanceUpdates() []*BalanceUpdate {
	if x != nil {
		return x.TotalBalanceUpdates
	}
	return nil
}

func (x *Transaction) GetTotalTokenBalanceUpdates() []*BalanceUpdate {
	if x != nil {
		return x.TotalTokenBalanceUpdates
	}
	return nil
}

func (x *Transaction) GetInstructions() []*Instruction {
	if x != nil {
		return x.Instructions
	}
	return nil
}

func (x *Transaction) GetLogs() []string {
	if x != nil {
		return x.Logs
	}
	return nil
}

func (x *Transaction) GetIndex() uint64 {
	if x != nil {
		return x.Index
	}
	return 0
}

type BlockHeader struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Slot          uint64                 `protobuf:"varint,1,opt,name=Slot,proto3" json:"Slot,omitempty"`
	Hash          []byte                 `protobuf:"bytes,2,opt,name=Hash,proto3" json:"Hash,omitempty"`
	ParentSlot    uint64                 `protobuf:"varint,4,opt,name=ParentSlot,proto3" json:"ParentSlot,omitempty"`
	Height        uint64                 `protobuf:"varint,5,opt,name=Height,proto3" json:"Height,omitempty"`
	Timestamp     int64                  `protobuf:"varint,6,opt,name=Timestamp,proto3" json:"Timestamp,omitempty"`
	ParentHash    []byte                 `protobuf:"bytes,7,opt,name=ParentHash,proto3" json:"ParentHash,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BlockHeader) Reset() {
	*x = BlockHeader{}
	mi := &file_solana_block_message_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *BlockHeader) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*BlockHeader) ProtoMessage() {}

func (x *BlockHeader) ProtoReflect() protoreflect.Message {
	mi := &file_solana_block_message_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 BlockHeader.ProtoReflect.Descriptor instead.
func (*BlockHeader) Descriptor() ([]byte, []int) {
	return file_solana_block_message_proto_rawDescGZIP(), []int{8}
}

func (x *BlockHeader) GetSlot() uint64 {
	if x != nil {
		return x.Slot
	}
	return 0
}

func (x *BlockHeader) GetHash() []byte {
	if x != nil {
		return x.Hash
	}
	return nil
}

func (x *BlockHeader) GetParentSlot() uint64 {
	if x != nil {
		return x.ParentSlot
	}
	return 0
}

func (x *BlockHeader) GetHeight() uint64 {
	if x != nil {
		return x.Height
	}
	return 0
}

func (x *BlockHeader) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *BlockHeader) GetParentHash() []byte {
	if x != nil {
		return x.ParentHash
	}
	return nil
}

type BlockMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Header        *BlockHeader           `protobuf:"bytes,1,opt,name=Header,proto3" json:"Header,omitempty"`
	Rewards       []*Reward              `protobuf:"bytes,2,rep,name=Rewards,proto3" json:"Rewards,omitempty"`
	Transactions  []*Transaction         `protobuf:"bytes,3,rep,name=Transactions,proto3" json:"Transactions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BlockMessage) Reset() {
	*x = BlockMessage{}
	mi := &file_solana_block_message_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *BlockMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*BlockMessage) ProtoMessage() {}

func (x *BlockMessage) ProtoReflect() protoreflect.Message {
	mi := &file_solana_block_message_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 BlockMessage.ProtoReflect.Descriptor instead.
func (*BlockMessage) Descriptor() ([]byte, []int) {
	return file_solana_block_message_proto_rawDescGZIP(), []int{9}
}

func (x *BlockMessage) GetHeader() *BlockHeader {
	if x != nil {
		return x.Header
	}
	return nil
}

func (x *BlockMessage) GetRewards() []*Reward {
	if x != nil {
		return x.Rewards
	}
	return nil
}

func (x *BlockMessage) GetTransactions() []*Transaction {
	if x != nil {
		return x.Transactions
	}
	return nil
}

var File_solana_block_message_proto protoreflect.FileDescriptor

const file_solana_block_message_proto_rawDesc = "" +
	"\n" +
	"\x1asolana/block_message.proto\x12\x0fsolana_messages\"\xa0\x01\n" +
	"\aAccount\x12\x18\n" +
	"\aAddress\x18\x01 \x01(\fR\aAddress\x12\x1a\n" +
	"\bIsSigner\x18\x02 \x01(\bR\bIsSigner\x12\x1e\n" +
	"\n" +
	"IsWritable\x18\x03 \x01(\bR\n" +
	"IsWritable\x125\n" +
	"\x05Token\x18\x04 \x01(\v2\x1a.solana_messages.TokenInfoH\x00R\x05Token\x88\x01\x01B\b\n" +
	"\x06_Token\"\x87\x01\n" +
	"\tTokenInfo\x12\x12\n" +
	"\x04Mint\x18\x01 \x01(\fR\x04Mint\x12\x14\n" +
	"\x05Owner\x18\x02 \x01(\fR\x05Owner\x12\x1a\n" +
	"\bDecimals\x18\x03 \x01(\rR\bDecimals\x12\x1c\n" +
	"\tProgramId\x18\x04 \x01(\fR\tProgramId\x12\x16\n" +
	"\x06Supply\x18\x05 \x01(\x04R\x06Supply\"u\n" +
	"\rBalanceUpdate\x12\x1e\n" +
	"\n" +
	"PreBalance\x18\x01 \x01(\x04R\n" +
	"PreBalance\x12 \n" +
	"\vPostBalance\x18\x02 \x01(\x04R\vPostBalance\x12\"\n" +
	"\fAccountIndex\x18\x03 \x01(\rR\fAccountIndex\"\xcb\x03\n" +
	"\vInstruction\x120\n" +
	"\x13ProgramAccountIndex\x18\x01 \x01(\rR\x13ProgramAccountIndex\x12 \n" +
	"\vCallerIndex\x18\x02 \x01(\x04R\vCallerIndex\x12\x1e\n" +
	"\n" +
	"InnerIndex\x18\x03 \x01(\x04R\n" +
	"InnerIndex\x12\"\n" +
	"\fNestingLevel\x18\x04 \x01(\x04R\fNestingLevel\x12\x12\n" +
	"\x04Data\x18\x05 \x01(\fR\x04Data\x12&\n" +
	"\x0eAccountIndexes\x18\x06 \x03(\rR\x0eAccountIndexes\x12F\n" +
	"\x0eBalanceUpdates\x18\a \x03(\v2\x1e.solana_messages.BalanceUpdateR\x0eBalanceUpdates\x12P\n" +
	"\x13TokenBalanceUpdates\x18\b \x03(\v2\x1e.solana_messages.BalanceUpdateR\x13TokenBalanceUpdates\x12N\n" +
	"\x12TokenSupplyUpdates\x18\t \x03(\v2\x1e.solana_messages.BalanceUpdateR\x12TokenSupplyUpdates\"\xd9\x01\n" +
	"\x11TransactionHeader\x12\x10\n" +
	"\x03Fee\x18\x01 \x01(\x04R\x03Fee\x12\x1a\n" +
	"\bFeePayer\x18\x02 \x01(\fR\bFeePayer\x12(\n" +
	"\x0fRecentBlockhash\x18\x03 \x01(\fR\x0fRecentBlockhash\x12\x16\n" +
	"\x06Signer\x18\x04 \x01(\fR\x06Signer\x12\x1e\n" +
	"\n" +
	"Signatures\x18\x05 \x03(\fR\n" +
	"Signatures\x124\n" +
	"\bAccounts\x18\x06 \x03(\v2\x18.solana_messages.AccountR\bAccounts\"\xb9\x01\n" +
	"\x06Reward\x12\x18\n" +
	"\aAddress\x18\x01 \x01(\fR\aAddress\x12\x16\n" +
	"\x06Amount\x18\x02 \x01(\x03R\x06Amount\x12 \n" +
	"\vPostBalance\x18\x03 \x01(\x04R\vPostBalance\x12;\n" +
	"\n" +
	"RewardType\x18\x04 \x01(\x0e2\x1b.solana_messages.RewardTypeR\n" +
	"RewardType\x12\x1e\n" +
	"\n" +
	"Commission\x18\x05 \x01(\x04R\n" +
	"Commission\"Q\n" +
	"\x11TransactionStatus\x12\x18\n" +
	"\aSuccess\x18\x01 \x01(\bR\aSuccess\x12\"\n" +
	"\fErrorMessage\x18\x02 \x01(\tR\fErrorMessage\"\xbd\x03\n" +
	"\vTransaction\x12\x1c\n" +
	"\tSignature\x18\x01 \x01(\fR\tSignature\x12:\n" +
	"\x06Status\x18\x02 \x01(\v2\".solana_messages.TransactionStatusR\x06Status\x12:\n" +
	"\x06Header\x18\x03 \x01(\v2\".solana_messages.TransactionHeaderR\x06Header\x12P\n" +
	"\x13TotalBalanceUpdates\x18\x04 \x03(\v2\x1e.solana_messages.BalanceUpdateR\x13TotalBalanceUpdates\x12Z\n" +
	"\x18TotalTokenBalanceUpdates\x18\x05 \x03(\v2\x1e.solana_messages.BalanceUpdateR\x18TotalTokenBalanceUpdates\x12@\n" +
	"\fInstructions\x18\a \x03(\v2\x1c.solana_messages.InstructionR\fInstructions\x12\x12\n" +
	"\x04Logs\x18\b \x03(\tR\x04Logs\x12\x14\n" +
	"\x05Index\x18\t \x01(\x04R\x05Index\"\xab\x01\n" +
	"\vBlockHeader\x12\x12\n" +
	"\x04Slot\x18\x01 \x01(\x04R\x04Slot\x12\x12\n" +
	"\x04Hash\x18\x02 \x01(\fR\x04Hash\x12\x1e\n" +
	"\n" +
	"ParentSlot\x18\x04 \x01(\x04R\n" +
	"ParentSlot\x12\x16\n" +
	"\x06Height\x18\x05 \x01(\x04R\x06Height\x12\x1c\n" +
	"\tTimestamp\x18\x06 \x01(\x03R\tTimestamp\x12\x1e\n" +
	"\n" +
	"ParentHash\x18\a \x01(\fR\n" +
	"ParentHash\"\xb9\x01\n" +
	"\fBlockMessage\x124\n" +
	"\x06Header\x18\x01 \x01(\v2\x1c.solana_messages.BlockHeaderR\x06Header\x121\n" +
	"\aRewards\x18\x02 \x03(\v2\x17.solana_messages.RewardR\aRewards\x12@\n" +
	"\fTransactions\x18\x03 \x03(\v2\x1c.solana_messages.TransactionR\fTransactions*O\n" +
	"\n" +
	"RewardType\x12\x15\n" +
	"\x11RewardTypeUnknown\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\x04b\x06proto3"

var (
	file_solana_block_message_proto_rawDescOnce sync.Once
	file_solana_block_message_proto_rawDescData []byte
)

func file_solana_block_message_proto_rawDescGZIP() []byte {
	file_solana_block_message_proto_rawDescOnce.Do(func() {
		file_solana_block_message_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_solana_block_message_proto_rawDesc), len(file_solana_block_message_proto_rawDesc)))
	})
	return file_solana_block_message_proto_rawDescData
}

var file_solana_block_message_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_solana_block_message_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
var file_solana_block_message_proto_goTypes = []any{
	(RewardType)(0),           // 0: solana_messages.RewardType
	(*Account)(nil),           // 1: solana_messages.Account
	(*TokenInfo)(nil),         // 2: solana_messages.TokenInfo
	(*BalanceUpdate)(nil),     // 3: solana_messages.BalanceUpdate
	(*Instruction)(nil),       // 4: solana_messages.Instruction
	(*TransactionHeader)(nil), // 5: solana_messages.TransactionHeader
	(*Reward)(nil),            // 6: solana_messages.Reward
	(*TransactionStatus)(nil), // 7: solana_messages.TransactionStatus
	(*Transaction)(nil),       // 8: solana_messages.Transaction
	(*BlockHeader)(nil),       // 9: solana_messages.BlockHeader
	(*BlockMessage)(nil),      // 10: solana_messages.BlockMessage
}
var file_solana_block_message_proto_depIdxs = []int32{
	2,  // 0: solana_messages.Account.Token:type_name -> solana_messages.TokenInfo
	3,  // 1: solana_messages.Instruction.BalanceUpdates:type_name -> solana_messages.BalanceUpdate
	3,  // 2: solana_messages.Instruction.TokenBalanceUpdates:type_name -> solana_messages.BalanceUpdate
	3,  // 3: solana_messages.Instruction.TokenSupplyUpdates:type_name -> solana_messages.BalanceUpdate
	1,  // 4: solana_messages.TransactionHeader.Accounts:type_name -> solana_messages.Account
	0,  // 5: solana_messages.Reward.RewardType:type_name -> solana_messages.RewardType
	7,  // 6: solana_messages.Transaction.Status:type_name -> solana_messages.TransactionStatus
	5,  // 7: solana_messages.Transaction.Header:type_name -> solana_messages.TransactionHeader
	3,  // 8: solana_messages.Transaction.TotalBalanceUpdates:type_name -> solana_messages.BalanceUpdate
	3,  // 9: solana_messages.Transaction.TotalTokenBalanceUpdates:type_name -> solana_messages.BalanceUpdate
	4,  // 10: solana_messages.Transaction.Instructions:type_name -> solana_messages.Instruction
	9,  // 11: solana_messages.BlockMessage.Header:type_name -> solana_messages.BlockHeader
	6,  // 12: solana_messages.BlockMessage.Rewards:type_name -> solana_messages.Reward
	8,  // 13: solana_messages.BlockMessage.Transactions:type_name -> solana_messages.Transaction
	14, // [14:14] is the sub-list for method output_type
	14, // [14:14] is the sub-list for method input_type
	14, // [14:14] is the sub-list for extension type_name
	14, // [14:14] is the sub-list for extension extendee
	0,  // [0:14] is the sub-list for field type_name
}

func init() { file_solana_block_message_proto_init() }
func file_solana_block_message_proto_init() {
	if File_solana_block_message_proto != nil {
		return
	}
	file_solana_block_message_proto_msgTypes[0].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_solana_block_message_proto_rawDesc), len(file_solana_block_message_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   10,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_solana_block_message_proto_goTypes,
		DependencyIndexes: file_solana_block_message_proto_depIdxs,
		EnumInfos:         file_solana_block_message_proto_enumTypes,
		MessageInfos:      file_solana_block_message_proto_msgTypes,
	}.Build()
	File_solana_block_message_proto = out.File
	file_solana_block_message_proto_goTypes = nil
	file_solana_block_message_proto_depIdxs = nil
}