// Copyright 2020. The Tari Project
//
// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
// following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
// disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
// following disclaimer in the documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
// products derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
// USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v3.6.1
// source: block.proto

package block

import (
	transaction "pool/internal/server/proxy/proto/transaction"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"

	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
)

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

// The permitted pow algorithms
type PowAlgo_PowAlgos int32

const (
	PowAlgo_POW_ALGOS_RANDOMXM PowAlgo_PowAlgos = 0 // Accessible as `grpc::pow_algo::PowAlgos::RandomxM`
	PowAlgo_POW_ALGOS_SHA3X    PowAlgo_PowAlgos = 1 // Accessible as `grpc::pow_algo::PowAlgos::Sha3x`
	PowAlgo_POW_ALGOS_RANDOMXT PowAlgo_PowAlgos = 2 // Accessible as `grpc::pow_algo::PowAlgos::RandomxT`
)

// Enum value maps for PowAlgo_PowAlgos.
var (
	PowAlgo_PowAlgos_name = map[int32]string{
		0: "POW_ALGOS_RANDOMXM",
		1: "POW_ALGOS_SHA3X",
		2: "POW_ALGOS_RANDOMXT",
	}
	PowAlgo_PowAlgos_value = map[string]int32{
		"POW_ALGOS_RANDOMXM": 0,
		"POW_ALGOS_SHA3X":    1,
		"POW_ALGOS_RANDOMXT": 2,
	}
)

func (x PowAlgo_PowAlgos) Enum() *PowAlgo_PowAlgos {
	p := new(PowAlgo_PowAlgos)
	*p = x
	return p
}

func (x PowAlgo_PowAlgos) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (PowAlgo_PowAlgos) Descriptor() protoreflect.EnumDescriptor {
	return file_block_proto_enumTypes[0].Descriptor()
}

func (PowAlgo_PowAlgos) Type() protoreflect.EnumType {
	return &file_block_proto_enumTypes[0]
}

func (x PowAlgo_PowAlgos) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use PowAlgo_PowAlgos.Descriptor instead.
func (PowAlgo_PowAlgos) EnumDescriptor() ([]byte, []int) {
	return file_block_proto_rawDescGZIP(), []int{2, 0}
}

// The BlockHeader contains all the metadata for the block, including proof of work, a link to the previous block
// and the transaction kernels.
type BlockHeader struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The hash of the block
	Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	// Version of the block
	Version uint32 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	// Height of this block since the genesis block (height 0)
	Height uint64 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	// Hash of the block previous to this in the chain.
	PrevHash []byte `protobuf:"bytes,4,opt,name=prev_hash,json=prevHash,proto3" json:"prev_hash,omitempty"`
	// Timestamp at which the block was built.
	Timestamp uint64 `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// This is the UTXO merkle root of the outputs in the blockchain
	OutputMr []byte `protobuf:"bytes,6,opt,name=output_mr,json=outputMr,proto3" json:"output_mr,omitempty"`
	// This is the merkle root of all outputs in this block
	BlockOutputMr []byte `protobuf:"bytes,7,opt,name=block_output_mr,json=blockOutputMr,proto3" json:"block_output_mr,omitempty"`
	// This is the MMR root of the kernels
	KernelMr []byte `protobuf:"bytes,8,opt,name=kernel_mr,json=kernelMr,proto3" json:"kernel_mr,omitempty"`
	// This is the Merkle root of the inputs in this block
	InputMr []byte `protobuf:"bytes,9,opt,name=input_mr,json=inputMr,proto3" json:"input_mr,omitempty"`
	// Total accumulated sum of kernel offsets since genesis block. We can derive the kernel offset sum for *this*
	// block from the total kernel offset of the previous block header.
	TotalKernelOffset []byte `protobuf:"bytes,10,opt,name=total_kernel_offset,json=totalKernelOffset,proto3" json:"total_kernel_offset,omitempty"`
	// Nonce increment used to mine this block.
	Nonce uint64 `protobuf:"varint,11,opt,name=nonce,proto3" json:"nonce,omitempty"`
	// Proof of work metadata
	Pow *ProofOfWork `protobuf:"bytes,12,opt,name=pow,proto3" json:"pow,omitempty"`
	// Kernel MMR size
	KernelMmrSize uint64 `protobuf:"varint,13,opt,name=kernel_mmr_size,json=kernelMmrSize,proto3" json:"kernel_mmr_size,omitempty"`
	// Output MMR size
	OutputMmrSize uint64 `protobuf:"varint,14,opt,name=output_mmr_size,json=outputMmrSize,proto3" json:"output_mmr_size,omitempty"`
	// Sum of script offsets for all kernels in this block.
	TotalScriptOffset []byte `protobuf:"bytes,15,opt,name=total_script_offset,json=totalScriptOffset,proto3" json:"total_script_offset,omitempty"`
	// Merkle root of validator nodes
	ValidatorNodeMr []byte `protobuf:"bytes,16,opt,name=validator_node_mr,json=validatorNodeMr,proto3" json:"validator_node_mr,omitempty"`
	// Validator size
	ValidatorNodeSize uint64 `protobuf:"varint,17,opt,name=validator_node_size,json=validatorNodeSize,proto3" json:"validator_node_size,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *BlockHeader) Reset() {
	*x = BlockHeader{}
	mi := &file_block_proto_msgTypes[0]
	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_block_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 BlockHeader.ProtoReflect.Descriptor instead.
func (*BlockHeader) Descriptor() ([]byte, []int) {
	return file_block_proto_rawDescGZIP(), []int{0}
}

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

func (x *BlockHeader) GetVersion() uint32 {
	if x != nil {
		return x.Version
	}
	return 0
}

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

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

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

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

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

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

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

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

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

func (x *BlockHeader) GetPow() *ProofOfWork {
	if x != nil {
		return x.Pow
	}
	return nil
}

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

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

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

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

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

// The proof of work data structure that is included in the block header.
type ProofOfWork struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The algorithm used to mine this block
	//
	//	0 = Monero
	//	1 = Sha3X
	PowAlgo uint64 `protobuf:"varint,1,opt,name=pow_algo,json=powAlgo,proto3" json:"pow_algo,omitempty"`
	// Supplemental proof of work data. For example for Sha3x, this would be empty (only the block header is
	// required), but for Monero merge mining we need the Monero block header and RandomX seed hash.
	PowData       []byte `protobuf:"bytes,4,opt,name=pow_data,json=powData,proto3" json:"pow_data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ProofOfWork) ProtoMessage() {}

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

func (x *ProofOfWork) GetPowAlgo() uint64 {
	if x != nil {
		return x.PowAlgo
	}
	return 0
}

func (x *ProofOfWork) GetPowData() []byte {
	if x != nil {
		return x.PowData
	}
	return nil
}

// This is used to request the which pow algo should be used with the block template
type PowAlgo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The pow algo to use
	PowAlgo       PowAlgo_PowAlgos `protobuf:"varint,1,opt,name=pow_algo,json=powAlgo,proto3,enum=tari.rpc.PowAlgo_PowAlgos" json:"pow_algo,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PowAlgo) ProtoMessage() {}

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

func (x *PowAlgo) GetPowAlgo() PowAlgo_PowAlgos {
	if x != nil {
		return x.PowAlgo
	}
	return PowAlgo_POW_ALGOS_RANDOMXM
}

// A Minotari block. Blocks are linked together into a blockchain.
type Block struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The BlockHeader contains all the metadata for the block, including proof of work, a link to the previous block
	// and the transaction kernels.
	Header *BlockHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// The components of the block or transaction. The same struct can be used for either, since in Mimblewimble,
	// blocks consist of inputs, outputs and kernels, rather than transactions.
	Body          *transaction.AggregateBody `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Block) ProtoMessage() {}

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

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

func (x *Block) GetBody() *transaction.AggregateBody {
	if x != nil {
		return x.Body
	}
	return nil
}

// The representation of a historical block in the blockchain. It is essentially identical to a protocol-defined
// block but contains some extra metadata that clients such as Block Explorers will find interesting.
type HistoricalBlock struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The number of blocks that have been mined since this block, including this one. The current tip will have one
	// confirmation.
	Confirmations uint64 `protobuf:"varint,1,opt,name=confirmations,proto3" json:"confirmations,omitempty"`
	// The underlying block
	Block         *Block `protobuf:"bytes,2,opt,name=block,proto3" json:"block,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HistoricalBlock) ProtoMessage() {}

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

func (x *HistoricalBlock) GetConfirmations() uint64 {
	if x != nil {
		return x.Confirmations
	}
	return 0
}

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

// The NewBlockHeaderTemplate is used for the construction of a new mine-able block. It contains all the metadata for the block that the Base Node is able to complete on behalf of a Miner.
type NewBlockHeaderTemplate struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Version of the block
	Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// Height of this block since the genesis block (height 0)
	Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	// Hash of the block previous to this in the chain.
	PrevHash []byte `protobuf:"bytes,3,opt,name=prev_hash,json=prevHash,proto3" json:"prev_hash,omitempty"`
	// Total accumulated sum of kernel offsets since genesis block. We can derive the kernel offset sum for *this*
	// block from the total kernel offset of the previous block header.
	TotalKernelOffset []byte `protobuf:"bytes,4,opt,name=total_kernel_offset,json=totalKernelOffset,proto3" json:"total_kernel_offset,omitempty"`
	// Proof of work metadata
	Pow *ProofOfWork `protobuf:"bytes,5,opt,name=pow,proto3" json:"pow,omitempty"`
	// Sum of script offsets for all kernels in this block.
	TotalScriptOffset []byte `protobuf:"bytes,7,opt,name=total_script_offset,json=totalScriptOffset,proto3" json:"total_script_offset,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
	BlockHeader       *BlockHeader `protobuf:"bytes,8,opt,name=block_header,json=blockHeader,proto3" json:"block_header,omitempty"`
}

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

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

func (*NewBlockHeaderTemplate) ProtoMessage() {}

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

func (x *NewBlockHeaderTemplate) GetVersion() uint32 {
	if x != nil {
		return x.Version
	}
	return 0
}

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

func (x *NewBlockHeaderTemplate) GetPrevHash() []byte {
	if x != nil {
		return x.PrevHash
	}
	return nil
}

func (x *NewBlockHeaderTemplate) GetTotalKernelOffset() []byte {
	if x != nil {
		return x.TotalKernelOffset
	}
	return nil
}

func (x *NewBlockHeaderTemplate) GetPow() *ProofOfWork {
	if x != nil {
		return x.Pow
	}
	return nil
}

func (x *NewBlockHeaderTemplate) GetTotalScriptOffset() []byte {
	if x != nil {
		return x.TotalScriptOffset
	}
	return nil
}

// The new block template is used constructing a new partial block, allowing a miner to added the coinbase utxo and as a final step the Base node to add the MMR roots to the header.
type NewBlockTemplate struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The NewBlockHeaderTemplate is used for the construction of a new mineable block. It contains all the metadata for
	// the block that the Base Node is able to complete on behalf of a Miner.
	Header *NewBlockHeaderTemplate `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// This flag indicates if the inputs, outputs and kernels have been sorted internally, that is, the sort() method
	// has been called. This may be false even if all components are sorted.
	Body *transaction.AggregateBody `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
	// Sometimes the mempool has not synced to the latest tip, this flag indicates if the mempool is out of sync.
	// In most cases the next call to get_new_block_template will return a block with the mempool in sync.
	IsMempoolInSync bool `protobuf:"varint,3,opt,name=is_mempool_in_sync,json=isMempoolInSync,proto3" json:"is_mempool_in_sync,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*NewBlockTemplate) ProtoMessage() {}

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

func (x *NewBlockTemplate) GetHeader() *NewBlockHeaderTemplate {
	if x != nil {
		return x.Header
	}
	return nil
}

func (x *NewBlockTemplate) GetBody() *transaction.AggregateBody {
	if x != nil {
		return x.Body
	}
	return nil
}

func (x *NewBlockTemplate) GetIsMempoolInSync() bool {
	if x != nil {
		return x.IsMempoolInSync
	}
	return false
}

var File_block_proto protoreflect.FileDescriptor

const file_block_proto_rawDesc = "" +
	"\n" +
	"\vblock.proto\x12\btari.rpc\x1a\x11transaction.proto\"\xd6\x04\n" +
	"\vBlockHeader\x12\x12\n" +
	"\x04hash\x18\x01 \x01(\fR\x04hash\x12\x18\n" +
	"\aversion\x18\x02 \x01(\rR\aversion\x12\x16\n" +
	"\x06height\x18\x03 \x01(\x04R\x06height\x12\x1b\n" +
	"\tprev_hash\x18\x04 \x01(\fR\bprevHash\x12\x1c\n" +
	"\ttimestamp\x18\x05 \x01(\x04R\ttimestamp\x12\x1b\n" +
	"\toutput_mr\x18\x06 \x01(\fR\boutputMr\x12&\n" +
	"\x0fblock_output_mr\x18\a \x01(\fR\rblockOutputMr\x12\x1b\n" +
	"\tkernel_mr\x18\b \x01(\fR\bkernelMr\x12\x19\n" +
	"\binput_mr\x18\t \x01(\fR\ainputMr\x12.\n" +
	"\x13total_kernel_offset\x18\n" +
	" \x01(\fR\x11totalKernelOffset\x12\x14\n" +
	"\x05nonce\x18\v \x01(\x04R\x05nonce\x12'\n" +
	"\x03pow\x18\f \x01(\v2\x15.tari.rpc.ProofOfWorkR\x03pow\x12&\n" +
	"\x0fkernel_mmr_size\x18\r \x01(\x04R\rkernelMmrSize\x12&\n" +
	"\x0foutput_mmr_size\x18\x0e \x01(\x04R\routputMmrSize\x12.\n" +
	"\x13total_script_offset\x18\x0f \x01(\fR\x11totalScriptOffset\x12*\n" +
	"\x11validator_node_mr\x18\x10 \x01(\fR\x0fvalidatorNodeMr\x12.\n" +
	"\x13validator_node_size\x18\x11 \x01(\x04R\x11validatorNodeSize\"C\n" +
	"\vProofOfWork\x12\x19\n" +
	"\bpow_algo\x18\x01 \x01(\x04R\apowAlgo\x12\x19\n" +
	"\bpow_data\x18\x04 \x01(\fR\apowData\"\x91\x01\n" +
	"\aPowAlgo\x125\n" +
	"\bpow_algo\x18\x01 \x01(\x0e2\x1a.tari.rpc.PowAlgo.PowAlgosR\apowAlgo\"O\n" +
	"\bPowAlgos\x12\x16\n" +
	"\x12POW_ALGOS_RANDOMXM\x10\x00\x12\x13\n" +
	"\x0fPOW_ALGOS_SHA3X\x10\x01\x12\x16\n" +
	"\x12POW_ALGOS_RANDOMXT\x10\x02\"c\n" +
	"\x05Block\x12-\n" +
	"\x06header\x18\x01 \x01(\v2\x15.tari.rpc.BlockHeaderR\x06header\x12+\n" +
	"\x04body\x18\x02 \x01(\v2\x17.tari.rpc.AggregateBodyR\x04body\"^\n" +
	"\x0fHistoricalBlock\x12$\n" +
	"\rconfirmations\x18\x01 \x01(\x04R\rconfirmations\x12%\n" +
	"\x05block\x18\x02 \x01(\v2\x0f.tari.rpc.BlockR\x05block\"\xf0\x01\n" +
	"\x16NewBlockHeaderTemplate\x12\x18\n" +
	"\aversion\x18\x01 \x01(\rR\aversion\x12\x16\n" +
	"\x06height\x18\x02 \x01(\x04R\x06height\x12\x1b\n" +
	"\tprev_hash\x18\x03 \x01(\fR\bprevHash\x12.\n" +
	"\x13total_kernel_offset\x18\x04 \x01(\fR\x11totalKernelOffset\x12'\n" +
	"\x03pow\x18\x05 \x01(\v2\x15.tari.rpc.ProofOfWorkR\x03pow\x12.\n" +
	"\x13total_script_offset\x18\a \x01(\fR\x11totalScriptOffset\"\xa6\x01\n" +
	"\x10NewBlockTemplate\x128\n" +
	"\x06header\x18\x01 \x01(\v2 .tari.rpc.NewBlockHeaderTemplateR\x06header\x12+\n" +
	"\x04body\x18\x02 \x01(\v2\x17.tari.rpc.AggregateBodyR\x04body\x12+\n" +
	"\x12is_mempool_in_sync\x18\x03 \x01(\bR\x0fisMempoolInSyncB$Z\"pool/internal/gbt/tari/block;blockb\x06proto3"

var (
	file_block_proto_rawDescOnce sync.Once
	file_block_proto_rawDescData []byte
)

func file_block_proto_rawDescGZIP() []byte {
	file_block_proto_rawDescOnce.Do(func() {
		file_block_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_block_proto_rawDesc), len(file_block_proto_rawDesc)))
	})
	return file_block_proto_rawDescData
}

var file_block_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_block_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
var file_block_proto_goTypes = []any{
	(PowAlgo_PowAlgos)(0),             // 0: tari.rpc.PowAlgo.PowAlgos
	(*BlockHeader)(nil),               // 1: tari.rpc.BlockHeader
	(*ProofOfWork)(nil),               // 2: tari.rpc.ProofOfWork
	(*PowAlgo)(nil),                   // 3: tari.rpc.PowAlgo
	(*Block)(nil),                     // 4: tari.rpc.Block
	(*HistoricalBlock)(nil),           // 5: tari.rpc.HistoricalBlock
	(*NewBlockHeaderTemplate)(nil),    // 6: tari.rpc.NewBlockHeaderTemplate
	(*NewBlockTemplate)(nil),          // 7: tari.rpc.NewBlockTemplate
	(*transaction.AggregateBody)(nil), // 8: tari.rpc.AggregateBody
}
var file_block_proto_depIdxs = []int32{
	2, // 0: tari.rpc.BlockHeader.pow:type_name -> tari.rpc.ProofOfWork
	0, // 1: tari.rpc.PowAlgo.pow_algo:type_name -> tari.rpc.PowAlgo.PowAlgos
	1, // 2: tari.rpc.Block.header:type_name -> tari.rpc.BlockHeader
	8, // 3: tari.rpc.Block.body:type_name -> tari.rpc.AggregateBody
	4, // 4: tari.rpc.HistoricalBlock.block:type_name -> tari.rpc.Block
	2, // 5: tari.rpc.NewBlockHeaderTemplate.pow:type_name -> tari.rpc.ProofOfWork
	6, // 6: tari.rpc.NewBlockTemplate.header:type_name -> tari.rpc.NewBlockHeaderTemplate
	8, // 7: tari.rpc.NewBlockTemplate.body:type_name -> tari.rpc.AggregateBody
	8, // [8:8] is the sub-list for method output_type
	8, // [8:8] 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_block_proto_init() }
func file_block_proto_init() {
	if File_block_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_block_proto_rawDesc), len(file_block_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   7,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_block_proto_goTypes,
		DependencyIndexes: file_block_proto_depIdxs,
		EnumInfos:         file_block_proto_enumTypes,
		MessageInfos:      file_block_proto_msgTypes,
	}.Build()
	File_block_proto = out.File
	file_block_proto_goTypes = nil
	file_block_proto_depIdxs = nil
}