// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v5.29.3
// source: rpc.proto

package evm

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)
)

// Request for getting the chain ID
type ChainIdRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ChainIdRequest) ProtoMessage() {}

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

// Response containing the chain ID
type ChainIdResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// EIP-155 chain ID
	ChainId       uint64 `protobuf:"varint,1,opt,name=chainId,proto3" json:"chainId,omitempty"`
	GenesisHash   []byte `protobuf:"bytes,2,opt,name=genesisHash,proto3" json:"genesisHash,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ChainIdResponse) ProtoMessage() {}

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

func (x *ChainIdResponse) GetChainId() uint64 {
	if x != nil {
		return x.ChainId
	}
	return 0
}

func (x *ChainIdResponse) GetGenesisHash() []byte {
	if x != nil {
		return x.GenesisHash
	}
	return nil
}

// Request for getting a block by number
type GetBlockByNumberRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The block number to retrieve (hex number or "latest", "earliest", "pending" tags)
	BlockNumber string `protobuf:"bytes,1,opt,name=blockNumber,proto3" json:"blockNumber,omitempty"`
	// Whether to include full transaction details (if false, only transaction hashes are returned)
	IncludeTransactions bool `protobuf:"varint,2,opt,name=includeTransactions,proto3" json:"includeTransactions,omitempty"`
	// Optional chain ID to use for the request
	ChainId *uint64 `protobuf:"varint,3,opt,name=chainId,proto3,oneof" json:"chainId,omitempty"`
	// Optional genesis hash to narrow down identical networks with the same chain ID
	ChainGenesisHash []byte `protobuf:"bytes,4,opt,name=chainGenesisHash,proto3,oneof" json:"chainGenesisHash,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*GetBlockByNumberRequest) ProtoMessage() {}

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

func (x *GetBlockByNumberRequest) GetBlockNumber() string {
	if x != nil {
		return x.BlockNumber
	}
	return ""
}

func (x *GetBlockByNumberRequest) GetIncludeTransactions() bool {
	if x != nil {
		return x.IncludeTransactions
	}
	return false
}

func (x *GetBlockByNumberRequest) GetChainId() uint64 {
	if x != nil && x.ChainId != nil {
		return *x.ChainId
	}
	return 0
}

func (x *GetBlockByNumberRequest) GetChainGenesisHash() []byte {
	if x != nil {
		return x.ChainGenesisHash
	}
	return nil
}

// Request for getting a block by hash
type GetBlockByHashRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The block hash to retrieve
	BlockHash []byte `protobuf:"bytes,1,opt,name=blockHash,proto3" json:"blockHash,omitempty"`
	// Whether to include full transaction details (if false, only transaction hashes are returned)
	IncludeTransactions bool `protobuf:"varint,2,opt,name=includeTransactions,proto3" json:"includeTransactions,omitempty"`
	// Optional chain ID to use for the request
	ChainId *uint64 `protobuf:"varint,3,opt,name=chainId,proto3,oneof" json:"chainId,omitempty"`
	// Optional genesis hash to narrow down identical networks with the same chain ID
	ChainGenesisHash []byte `protobuf:"bytes,4,opt,name=chainGenesisHash,proto3,oneof" json:"chainGenesisHash,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*GetBlockByHashRequest) ProtoMessage() {}

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

func (x *GetBlockByHashRequest) GetBlockHash() []byte {
	if x != nil {
		return x.BlockHash
	}
	return nil
}

func (x *GetBlockByHashRequest) GetIncludeTransactions() bool {
	if x != nil {
		return x.IncludeTransactions
	}
	return false
}

func (x *GetBlockByHashRequest) GetChainId() uint64 {
	if x != nil && x.ChainId != nil {
		return *x.ChainId
	}
	return 0
}

func (x *GetBlockByHashRequest) GetChainGenesisHash() []byte {
	if x != nil {
		return x.ChainGenesisHash
	}
	return nil
}

// Response containing the requested block
type GetBlockResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The requested block, null if not found
	Block *BlockHeader `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
	// Transaction data (format depends on includeTransactions flag in request)
	// If includeTransactions is false, this contains transaction hashes (32 bytes each)
	// If includeTransactions is true, this should be empty and fullTransactions field should be used
	Transactions [][]byte `protobuf:"bytes,2,rep,name=transactions,proto3" json:"transactions,omitempty"`
	// Optional chain ID to use for the request
	ChainId *uint64 `protobuf:"varint,5,opt,name=chainId,proto3,oneof" json:"chainId,omitempty"`
	// Optional genesis hash to narrow down identical networks with the same chain ID
	ChainGenesisHash []byte `protobuf:"bytes,6,opt,name=chainGenesisHash,proto3,oneof" json:"chainGenesisHash,omitempty"`
	// Full transaction objects (only populated when includeTransactions is true)
	FullTransactions []*Transaction `protobuf:"bytes,7,rep,name=fullTransactions,proto3" json:"fullTransactions,omitempty"`
	// Withdrawals (only populated when includeTransactions is true)
	Withdrawals   []*Withdrawal `protobuf:"bytes,8,rep,name=withdrawals,proto3" json:"withdrawals,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetBlockResponse) ProtoMessage() {}

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

func (x *GetBlockResponse) GetBlock() *BlockHeader {
	if x != nil {
		return x.Block
	}
	return nil
}

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

func (x *GetBlockResponse) GetChainId() uint64 {
	if x != nil && x.ChainId != nil {
		return *x.ChainId
	}
	return 0
}

func (x *GetBlockResponse) GetChainGenesisHash() []byte {
	if x != nil {
		return x.ChainGenesisHash
	}
	return nil
}

func (x *GetBlockResponse) GetFullTransactions() []*Transaction {
	if x != nil {
		return x.FullTransactions
	}
	return nil
}

func (x *GetBlockResponse) GetWithdrawals() []*Withdrawal {
	if x != nil {
		return x.Withdrawals
	}
	return nil
}

// Request for getting logs
type GetLogsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Starting block number (inclusive)
	FromBlock *uint64 `protobuf:"varint,1,opt,name=fromBlock,proto3,oneof" json:"fromBlock,omitempty"`
	// Ending block number (inclusive)
	ToBlock *uint64 `protobuf:"varint,2,opt,name=toBlock,proto3,oneof" json:"toBlock,omitempty"`
	// Contract addresses to filter by (empty means all addresses)
	Addresses [][]byte `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"`
	// Topics to filter by (each position can have multiple possible values)
	// topics[0] is an array of possible values for the first topic
	// topics[1] is an array of possible values for the second topic, etc.
	Topics []*TopicFilter `protobuf:"bytes,4,rep,name=topics,proto3" json:"topics,omitempty"`
	// Block hash to filter by (alternative to fromBlock/toBlock)
	BlockHash []byte `protobuf:"bytes,5,opt,name=blockHash,proto3,oneof" json:"blockHash,omitempty"`
	// Optional chain ID to use for the request
	ChainId *uint64 `protobuf:"varint,6,opt,name=chainId,proto3,oneof" json:"chainId,omitempty"`
	// Optional genesis hash to narrow down identical networks with the same chain ID
	ChainGenesisHash []byte `protobuf:"bytes,7,opt,name=chainGenesisHash,proto3,oneof" json:"chainGenesisHash,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *GetLogsRequest) Reset() {
	*x = GetLogsRequest{}
	mi := &file_rpc_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetLogsRequest) ProtoMessage() {}

func (x *GetLogsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_rpc_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 GetLogsRequest.ProtoReflect.Descriptor instead.
func (*GetLogsRequest) Descriptor() ([]byte, []int) {
	return file_rpc_proto_rawDescGZIP(), []int{5}
}

func (x *GetLogsRequest) GetFromBlock() uint64 {
	if x != nil && x.FromBlock != nil {
		return *x.FromBlock
	}
	return 0
}

func (x *GetLogsRequest) GetToBlock() uint64 {
	if x != nil && x.ToBlock != nil {
		return *x.ToBlock
	}
	return 0
}

func (x *GetLogsRequest) GetAddresses() [][]byte {
	if x != nil {
		return x.Addresses
	}
	return nil
}

func (x *GetLogsRequest) GetTopics() []*TopicFilter {
	if x != nil {
		return x.Topics
	}
	return nil
}

func (x *GetLogsRequest) GetBlockHash() []byte {
	if x != nil {
		return x.BlockHash
	}
	return nil
}

func (x *GetLogsRequest) GetChainId() uint64 {
	if x != nil && x.ChainId != nil {
		return *x.ChainId
	}
	return 0
}

func (x *GetLogsRequest) GetChainGenesisHash() []byte {
	if x != nil {
		return x.ChainGenesisHash
	}
	return nil
}

// Filter for log topics at a specific position
type TopicFilter struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Possible values for this topic position (OR condition)
	Values        [][]byte `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TopicFilter) ProtoMessage() {}

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

func (x *TopicFilter) GetValues() [][]byte {
	if x != nil {
		return x.Values
	}
	return nil
}

// Response containing matching logs
type GetLogsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Array of logs matching the filter criteria
	Logs          []*Log `protobuf:"bytes,1,rep,name=logs,proto3" json:"logs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetLogsResponse) Reset() {
	*x = GetLogsResponse{}
	mi := &file_rpc_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetLogsResponse) ProtoMessage() {}

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

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

// Request for getting a transaction by hash
type GetTransactionByHashRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The transaction hash to retrieve
	TransactionHash []byte `protobuf:"bytes,1,opt,name=transactionHash,proto3" json:"transactionHash,omitempty"`
	// Optional chain ID to use for the request
	ChainId *uint64 `protobuf:"varint,2,opt,name=chainId,proto3,oneof" json:"chainId,omitempty"`
	// Optional genesis hash to narrow down identical networks with the same chain ID
	ChainGenesisHash []byte `protobuf:"bytes,3,opt,name=chainGenesisHash,proto3,oneof" json:"chainGenesisHash,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*GetTransactionByHashRequest) ProtoMessage() {}

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

func (x *GetTransactionByHashRequest) GetTransactionHash() []byte {
	if x != nil {
		return x.TransactionHash
	}
	return nil
}

func (x *GetTransactionByHashRequest) GetChainId() uint64 {
	if x != nil && x.ChainId != nil {
		return *x.ChainId
	}
	return 0
}

func (x *GetTransactionByHashRequest) GetChainGenesisHash() []byte {
	if x != nil {
		return x.ChainGenesisHash
	}
	return nil
}

// Response containing the requested transaction
type GetTransactionByHashResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The requested transaction, null if not found
	Transaction   *Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetTransactionByHashResponse) ProtoMessage() {}

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

func (x *GetTransactionByHashResponse) GetTransaction() *Transaction {
	if x != nil {
		return x.Transaction
	}
	return nil
}

// Request for getting a transaction receipt
type GetTransactionReceiptRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The transaction hash to retrieve receipt for
	TransactionHash []byte `protobuf:"bytes,1,opt,name=transactionHash,proto3" json:"transactionHash,omitempty"`
	// Optional chain ID to use for the request
	ChainId *uint64 `protobuf:"varint,2,opt,name=chainId,proto3,oneof" json:"chainId,omitempty"`
	// Optional genesis hash to narrow down identical networks with the same chain ID
	ChainGenesisHash []byte `protobuf:"bytes,3,opt,name=chainGenesisHash,proto3,oneof" json:"chainGenesisHash,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *GetTransactionReceiptRequest) Reset() {
	*x = GetTransactionReceiptRequest{}
	mi := &file_rpc_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetTransactionReceiptRequest) ProtoMessage() {}

func (x *GetTransactionReceiptRequest) ProtoReflect() protoreflect.Message {
	mi := &file_rpc_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 GetTransactionReceiptRequest.ProtoReflect.Descriptor instead.
func (*GetTransactionReceiptRequest) Descriptor() ([]byte, []int) {
	return file_rpc_proto_rawDescGZIP(), []int{10}
}

func (x *GetTransactionReceiptRequest) GetTransactionHash() []byte {
	if x != nil {
		return x.TransactionHash
	}
	return nil
}

func (x *GetTransactionReceiptRequest) GetChainId() uint64 {
	if x != nil && x.ChainId != nil {
		return *x.ChainId
	}
	return 0
}

func (x *GetTransactionReceiptRequest) GetChainGenesisHash() []byte {
	if x != nil {
		return x.ChainGenesisHash
	}
	return nil
}

// Response containing the requested transaction receipt
type GetTransactionReceiptResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The requested receipt, null if not found
	Receipt       *Receipt `protobuf:"bytes,1,opt,name=receipt,proto3" json:"receipt,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetTransactionReceiptResponse) Reset() {
	*x = GetTransactionReceiptResponse{}
	mi := &file_rpc_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetTransactionReceiptResponse) ProtoMessage() {}

func (x *GetTransactionReceiptResponse) ProtoReflect() protoreflect.Message {
	mi := &file_rpc_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 GetTransactionReceiptResponse.ProtoReflect.Descriptor instead.
func (*GetTransactionReceiptResponse) Descriptor() ([]byte, []int) {
	return file_rpc_proto_rawDescGZIP(), []int{11}
}

func (x *GetTransactionReceiptResponse) GetReceipt() *Receipt {
	if x != nil {
		return x.Receipt
	}
	return nil
}

// Request for getting all receipts in a block
type GetBlockReceiptsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Block number as hex string (e.g., "0x14ee0030") or tag ("latest", "earliest", "pending")
	// Mutually exclusive with blockHash
	BlockNumber *string `protobuf:"bytes,1,opt,name=blockNumber,proto3,oneof" json:"blockNumber,omitempty"`
	// Block hash as bytes (32 bytes)
	// Mutually exclusive with blockNumber
	BlockHash []byte `protobuf:"bytes,2,opt,name=blockHash,proto3,oneof" json:"blockHash,omitempty"`
	// Optional chain ID to use for the request
	ChainId *uint64 `protobuf:"varint,3,opt,name=chainId,proto3,oneof" json:"chainId,omitempty"`
	// Optional genesis hash to narrow down identical networks with the same chain ID
	ChainGenesisHash []byte `protobuf:"bytes,4,opt,name=chainGenesisHash,proto3,oneof" json:"chainGenesisHash,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *GetBlockReceiptsRequest) Reset() {
	*x = GetBlockReceiptsRequest{}
	mi := &file_rpc_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetBlockReceiptsRequest) ProtoMessage() {}

func (x *GetBlockReceiptsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_rpc_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 GetBlockReceiptsRequest.ProtoReflect.Descriptor instead.
func (*GetBlockReceiptsRequest) Descriptor() ([]byte, []int) {
	return file_rpc_proto_rawDescGZIP(), []int{12}
}

func (x *GetBlockReceiptsRequest) GetBlockNumber() string {
	if x != nil && x.BlockNumber != nil {
		return *x.BlockNumber
	}
	return ""
}

func (x *GetBlockReceiptsRequest) GetBlockHash() []byte {
	if x != nil {
		return x.BlockHash
	}
	return nil
}

func (x *GetBlockReceiptsRequest) GetChainId() uint64 {
	if x != nil && x.ChainId != nil {
		return *x.ChainId
	}
	return 0
}

func (x *GetBlockReceiptsRequest) GetChainGenesisHash() []byte {
	if x != nil {
		return x.ChainGenesisHash
	}
	return nil
}

// Response containing all receipts for the requested block
type GetBlockReceiptsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Array of receipts for all transactions in the block
	Receipts      []*Receipt `protobuf:"bytes,1,rep,name=receipts,proto3" json:"receipts,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetBlockReceiptsResponse) Reset() {
	*x = GetBlockReceiptsResponse{}
	mi := &file_rpc_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetBlockReceiptsResponse) ProtoMessage() {}

func (x *GetBlockReceiptsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_rpc_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 GetBlockReceiptsResponse.ProtoReflect.Descriptor instead.
func (*GetBlockReceiptsResponse) Descriptor() ([]byte, []int) {
	return file_rpc_proto_rawDescGZIP(), []int{13}
}

func (x *GetBlockReceiptsResponse) GetReceipts() []*Receipt {
	if x != nil {
		return x.Receipts
	}
	return nil
}

var File_rpc_proto protoreflect.FileDescriptor

const file_rpc_proto_rawDesc = "" +
	"\n" +
	"\trpc.proto\x12\abds.evm\x1a\fmodels.proto\"\x10\n" +
	"\x0eChainIdRequest\"M\n" +
	"\x0fChainIdResponse\x12\x18\n" +
	"\achainId\x18\x01 \x01(\x04R\achainId\x12 \n" +
	"\vgenesisHash\x18\x02 \x01(\fR\vgenesisHash\"\xde\x01\n" +
	"\x17GetBlockByNumberRequest\x12 \n" +
	"\vblockNumber\x18\x01 \x01(\tR\vblockNumber\x120\n" +
	"\x13includeTransactions\x18\x02 \x01(\bR\x13includeTransactions\x12\x1d\n" +
	"\achainId\x18\x03 \x01(\x04H\x00R\achainId\x88\x01\x01\x12/\n" +
	"\x10chainGenesisHash\x18\x04 \x01(\fH\x01R\x10chainGenesisHash\x88\x01\x01B\n" +
	"\n" +
	"\b_chainIdB\x13\n" +
	"\x11_chainGenesisHash\"\xd8\x01\n" +
	"\x15GetBlockByHashRequest\x12\x1c\n" +
	"\tblockHash\x18\x01 \x01(\fR\tblockHash\x120\n" +
	"\x13includeTransactions\x18\x02 \x01(\bR\x13includeTransactions\x12\x1d\n" +
	"\achainId\x18\x03 \x01(\x04H\x00R\achainId\x88\x01\x01\x12/\n" +
	"\x10chainGenesisHash\x18\x04 \x01(\fH\x01R\x10chainGenesisHash\x88\x01\x01B\n" +
	"\n" +
	"\b_chainIdB\x13\n" +
	"\x11_chainGenesisHash\"\xcc\x02\n" +
	"\x10GetBlockResponse\x12*\n" +
	"\x05block\x18\x01 \x01(\v2\x14.bds.evm.BlockHeaderR\x05block\x12\"\n" +
	"\ftransactions\x18\x02 \x03(\fR\ftransactions\x12\x1d\n" +
	"\achainId\x18\x05 \x01(\x04H\x00R\achainId\x88\x01\x01\x12/\n" +
	"\x10chainGenesisHash\x18\x06 \x01(\fH\x01R\x10chainGenesisHash\x88\x01\x01\x12@\n" +
	"\x10fullTransactions\x18\a \x03(\v2\x14.bds.evm.TransactionR\x10fullTransactions\x125\n" +
	"\vwithdrawals\x18\b \x03(\v2\x13.bds.evm.WithdrawalR\vwithdrawalsB\n" +
	"\n" +
	"\b_chainIdB\x13\n" +
	"\x11_chainGenesisHash\"\xda\x02\n" +
	"\x0eGetLogsRequest\x12!\n" +
	"\tfromBlock\x18\x01 \x01(\x04H\x00R\tfromBlock\x88\x01\x01\x12\x1d\n" +
	"\atoBlock\x18\x02 \x01(\x04H\x01R\atoBlock\x88\x01\x01\x12\x1c\n" +
	"\taddresses\x18\x03 \x03(\fR\taddresses\x12,\n" +
	"\x06topics\x18\x04 \x03(\v2\x14.bds.evm.TopicFilterR\x06topics\x12!\n" +
	"\tblockHash\x18\x05 \x01(\fH\x02R\tblockHash\x88\x01\x01\x12\x1d\n" +
	"\achainId\x18\x06 \x01(\x04H\x03R\achainId\x88\x01\x01\x12/\n" +
	"\x10chainGenesisHash\x18\a \x01(\fH\x04R\x10chainGenesisHash\x88\x01\x01B\f\n" +
	"\n" +
	"_fromBlockB\n" +
	"\n" +
	"\b_toBlockB\f\n" +
	"\n" +
	"_blockHashB\n" +
	"\n" +
	"\b_chainIdB\x13\n" +
	"\x11_chainGenesisHash\"%\n" +
	"\vTopicFilter\x12\x16\n" +
	"\x06values\x18\x01 \x03(\fR\x06values\"3\n" +
	"\x0fGetLogsResponse\x12 \n" +
	"\x04logs\x18\x01 \x03(\v2\f.bds.evm.LogR\x04logs\"\xb8\x01\n" +
	"\x1bGetTransactionByHashRequest\x12(\n" +
	"\x0ftransactionHash\x18\x01 \x01(\fR\x0ftransactionHash\x12\x1d\n" +
	"\achainId\x18\x02 \x01(\x04H\x00R\achainId\x88\x01\x01\x12/\n" +
	"\x10chainGenesisHash\x18\x03 \x01(\fH\x01R\x10chainGenesisHash\x88\x01\x01B\n" +
	"\n" +
	"\b_chainIdB\x13\n" +
	"\x11_chainGenesisHash\"V\n" +
	"\x1cGetTransactionByHashResponse\x126\n" +
	"\vtransaction\x18\x01 \x01(\v2\x14.bds.evm.TransactionR\vtransaction\"\xb9\x01\n" +
	"\x1cGetTransactionReceiptRequest\x12(\n" +
	"\x0ftransactionHash\x18\x01 \x01(\fR\x0ftransactionHash\x12\x1d\n" +
	"\achainId\x18\x02 \x01(\x04H\x00R\achainId\x88\x01\x01\x12/\n" +
	"\x10chainGenesisHash\x18\x03 \x01(\fH\x01R\x10chainGenesisHash\x88\x01\x01B\n" +
	"\n" +
	"\b_chainIdB\x13\n" +
	"\x11_chainGenesisHash\"K\n" +
	"\x1dGetTransactionReceiptResponse\x12*\n" +
	"\areceipt\x18\x01 \x01(\v2\x10.bds.evm.ReceiptR\areceipt\"\xf2\x01\n" +
	"\x17GetBlockReceiptsRequest\x12%\n" +
	"\vblockNumber\x18\x01 \x01(\tH\x00R\vblockNumber\x88\x01\x01\x12!\n" +
	"\tblockHash\x18\x02 \x01(\fH\x01R\tblockHash\x88\x01\x01\x12\x1d\n" +
	"\achainId\x18\x03 \x01(\x04H\x02R\achainId\x88\x01\x01\x12/\n" +
	"\x10chainGenesisHash\x18\x04 \x01(\fH\x03R\x10chainGenesisHash\x88\x01\x01B\x0e\n" +
	"\f_blockNumberB\f\n" +
	"\n" +
	"_blockHashB\n" +
	"\n" +
	"\b_chainIdB\x13\n" +
	"\x11_chainGenesisHash\"H\n" +
	"\x18GetBlockReceiptsResponse\x12,\n" +
	"\breceipts\x18\x01 \x03(\v2\x10.bds.evm.ReceiptR\breceipts2\xd1\x04\n" +
	"\x0fRPCQueryService\x12<\n" +
	"\aChainId\x12\x17.bds.evm.ChainIdRequest\x1a\x18.bds.evm.ChainIdResponse\x12O\n" +
	"\x10GetBlockByNumber\x12 .bds.evm.GetBlockByNumberRequest\x1a\x19.bds.evm.GetBlockResponse\x12K\n" +
	"\x0eGetBlockByHash\x12\x1e.bds.evm.GetBlockByHashRequest\x1a\x19.bds.evm.GetBlockResponse\x12<\n" +
	"\aGetLogs\x12\x17.bds.evm.GetLogsRequest\x1a\x18.bds.evm.GetLogsResponse\x12c\n" +
	"\x14GetTransactionByHash\x12$.bds.evm.GetTransactionByHashRequest\x1a%.bds.evm.GetTransactionByHashResponse\x12f\n" +
	"\x15GetTransactionReceipt\x12%.bds.evm.GetTransactionReceiptRequest\x1a&.bds.evm.GetTransactionReceiptResponse\x12W\n" +
	"\x10GetBlockReceipts\x12 .bds.evm.GetBlockReceiptsRequest\x1a!.bds.evm.GetBlockReceiptsResponseB4Z2github.com/blockchain-data-standards/manifesto/evmb\x06proto3"

var (
	file_rpc_proto_rawDescOnce sync.Once
	file_rpc_proto_rawDescData []byte
)

func file_rpc_proto_rawDescGZIP() []byte {
	file_rpc_proto_rawDescOnce.Do(func() {
		file_rpc_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_rpc_proto_rawDesc), len(file_rpc_proto_rawDesc)))
	})
	return file_rpc_proto_rawDescData
}

var file_rpc_proto_msgTypes = make([]protoimpl.MessageInfo, 14)
var file_rpc_proto_goTypes = []any{
	(*ChainIdRequest)(nil),                // 0: bds.evm.ChainIdRequest
	(*ChainIdResponse)(nil),               // 1: bds.evm.ChainIdResponse
	(*GetBlockByNumberRequest)(nil),       // 2: bds.evm.GetBlockByNumberRequest
	(*GetBlockByHashRequest)(nil),         // 3: bds.evm.GetBlockByHashRequest
	(*GetBlockResponse)(nil),              // 4: bds.evm.GetBlockResponse
	(*GetLogsRequest)(nil),                // 5: bds.evm.GetLogsRequest
	(*TopicFilter)(nil),                   // 6: bds.evm.TopicFilter
	(*GetLogsResponse)(nil),               // 7: bds.evm.GetLogsResponse
	(*GetTransactionByHashRequest)(nil),   // 8: bds.evm.GetTransactionByHashRequest
	(*GetTransactionByHashResponse)(nil),  // 9: bds.evm.GetTransactionByHashResponse
	(*GetTransactionReceiptRequest)(nil),  // 10: bds.evm.GetTransactionReceiptRequest
	(*GetTransactionReceiptResponse)(nil), // 11: bds.evm.GetTransactionReceiptResponse
	(*GetBlockReceiptsRequest)(nil),       // 12: bds.evm.GetBlockReceiptsRequest
	(*GetBlockReceiptsResponse)(nil),      // 13: bds.evm.GetBlockReceiptsResponse
	(*BlockHeader)(nil),                   // 14: bds.evm.BlockHeader
	(*Transaction)(nil),                   // 15: bds.evm.Transaction
	(*Withdrawal)(nil),                    // 16: bds.evm.Withdrawal
	(*Log)(nil),                           // 17: bds.evm.Log
	(*Receipt)(nil),                       // 18: bds.evm.Receipt
}
var file_rpc_proto_depIdxs = []int32{
	14, // 0: bds.evm.GetBlockResponse.block:type_name -> bds.evm.BlockHeader
	15, // 1: bds.evm.GetBlockResponse.fullTransactions:type_name -> bds.evm.Transaction
	16, // 2: bds.evm.GetBlockResponse.withdrawals:type_name -> bds.evm.Withdrawal
	6,  // 3: bds.evm.GetLogsRequest.topics:type_name -> bds.evm.TopicFilter
	17, // 4: bds.evm.GetLogsResponse.logs:type_name -> bds.evm.Log
	15, // 5: bds.evm.GetTransactionByHashResponse.transaction:type_name -> bds.evm.Transaction
	18, // 6: bds.evm.GetTransactionReceiptResponse.receipt:type_name -> bds.evm.Receipt
	18, // 7: bds.evm.GetBlockReceiptsResponse.receipts:type_name -> bds.evm.Receipt
	0,  // 8: bds.evm.RPCQueryService.ChainId:input_type -> bds.evm.ChainIdRequest
	2,  // 9: bds.evm.RPCQueryService.GetBlockByNumber:input_type -> bds.evm.GetBlockByNumberRequest
	3,  // 10: bds.evm.RPCQueryService.GetBlockByHash:input_type -> bds.evm.GetBlockByHashRequest
	5,  // 11: bds.evm.RPCQueryService.GetLogs:input_type -> bds.evm.GetLogsRequest
	8,  // 12: bds.evm.RPCQueryService.GetTransactionByHash:input_type -> bds.evm.GetTransactionByHashRequest
	10, // 13: bds.evm.RPCQueryService.GetTransactionReceipt:input_type -> bds.evm.GetTransactionReceiptRequest
	12, // 14: bds.evm.RPCQueryService.GetBlockReceipts:input_type -> bds.evm.GetBlockReceiptsRequest
	1,  // 15: bds.evm.RPCQueryService.ChainId:output_type -> bds.evm.ChainIdResponse
	4,  // 16: bds.evm.RPCQueryService.GetBlockByNumber:output_type -> bds.evm.GetBlockResponse
	4,  // 17: bds.evm.RPCQueryService.GetBlockByHash:output_type -> bds.evm.GetBlockResponse
	7,  // 18: bds.evm.RPCQueryService.GetLogs:output_type -> bds.evm.GetLogsResponse
	9,  // 19: bds.evm.RPCQueryService.GetTransactionByHash:output_type -> bds.evm.GetTransactionByHashResponse
	11, // 20: bds.evm.RPCQueryService.GetTransactionReceipt:output_type -> bds.evm.GetTransactionReceiptResponse
	13, // 21: bds.evm.RPCQueryService.GetBlockReceipts:output_type -> bds.evm.GetBlockReceiptsResponse
	15, // [15:22] is the sub-list for method output_type
	8,  // [8:15] is the sub-list for method input_type
	8,  // [8:8] is the sub-list for extension type_name
	8,  // [8:8] is the sub-list for extension extendee
	0,  // [0:8] is the sub-list for field type_name
}

func init() { file_rpc_proto_init() }
func file_rpc_proto_init() {
	if File_rpc_proto != nil {
		return
	}
	file_models_proto_init()
	file_rpc_proto_msgTypes[2].OneofWrappers = []any{}
	file_rpc_proto_msgTypes[3].OneofWrappers = []any{}
	file_rpc_proto_msgTypes[4].OneofWrappers = []any{}
	file_rpc_proto_msgTypes[5].OneofWrappers = []any{}
	file_rpc_proto_msgTypes[8].OneofWrappers = []any{}
	file_rpc_proto_msgTypes[10].OneofWrappers = []any{}
	file_rpc_proto_msgTypes[12].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_rpc_proto_rawDesc), len(file_rpc_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   14,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_rpc_proto_goTypes,
		DependencyIndexes: file_rpc_proto_depIdxs,
		MessageInfos:      file_rpc_proto_msgTypes,
	}.Build()
	File_rpc_proto = out.File
	file_rpc_proto_goTypes = nil
	file_rpc_proto_depIdxs = nil
}
