784 lines
25 KiB
Go
784 lines
25 KiB
Go
// 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/gbt/tari/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
|
|
}
|
|
|
|
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
|
|
}
|