// Code generated by protoc-gen-go. DO NOT EDIT.
// source: bc.proto

/*
Package bc is a generated protocol buffer package.

It is generated from these files:
	bc.proto

It has these top-level messages:
	Hash
	Predicate
	DataItem
	BlockHeader
	RawTx
	RawBlock
*/
package bc

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

// DataType is the type for a DataItem.
type DataType int32

const (
	DataType_BYTES DataType = 0
	DataType_INT   DataType = 1
	DataType_TUPLE DataType = 2
)

var DataType_name = map[int32]string{
	0: "BYTES",
	1: "INT",
	2: "TUPLE",
}
var DataType_value = map[string]int32{
	"BYTES": 0,
	"INT":   1,
	"TUPLE": 2,
}

func (x DataType) String() string {
	return proto.EnumName(DataType_name, int32(x))
}
func (DataType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

// Hash is a 32-byte hash.
type Hash struct {
	V0 uint64 `protobuf:"fixed64,1,opt,name=v0" json:"v0,omitempty"`
	V1 uint64 `protobuf:"fixed64,2,opt,name=v1" json:"v1,omitempty"`
	V2 uint64 `protobuf:"fixed64,3,opt,name=v2" json:"v2,omitempty"`
	V3 uint64 `protobuf:"fixed64,4,opt,name=v3" json:"v3,omitempty"`
}

func (m *Hash) Reset()                    { *m = Hash{} }
func (m *Hash) String() string            { return proto.CompactTextString(m) }
func (*Hash) ProtoMessage()               {}
func (*Hash) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

func (m *Hash) GetV0() uint64 {
	if m != nil {
		return m.V0
	}
	return 0
}

func (m *Hash) GetV1() uint64 {
	if m != nil {
		return m.V1
	}
	return 0
}

func (m *Hash) GetV2() uint64 {
	if m != nil {
		return m.V2
	}
	return 0
}

func (m *Hash) GetV3() uint64 {
	if m != nil {
		return m.V3
	}
	return 0
}

// Predicate contains the quorum and pubkeys needed to authenticate a block.
type Predicate struct {
	Version int64 `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
	// These fields apply only when version is 1.
	Quorum  int32    `protobuf:"varint,2,opt,name=quorum" json:"quorum,omitempty"`
	Pubkeys [][]byte `protobuf:"bytes,3,rep,name=pubkeys,proto3" json:"pubkeys,omitempty"`
	// Fields for predicate versions other than 1.
	OtherFields []*DataItem `protobuf:"bytes,4,rep,name=other_fields,json=otherFields" json:"other_fields,omitempty"`
}

func (m *Predicate) Reset()                    { *m = Predicate{} }
func (m *Predicate) String() string            { return proto.CompactTextString(m) }
func (*Predicate) ProtoMessage()               {}
func (*Predicate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

func (m *Predicate) GetVersion() int64 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *Predicate) GetQuorum() int32 {
	if m != nil {
		return m.Quorum
	}
	return 0
}

func (m *Predicate) GetPubkeys() [][]byte {
	if m != nil {
		return m.Pubkeys
	}
	return nil
}

func (m *Predicate) GetOtherFields() []*DataItem {
	if m != nil {
		return m.OtherFields
	}
	return nil
}

// DataItem is a txvm plain-data item: bytes, int, or tuple.
type DataItem struct {
	Type  DataType    `protobuf:"varint,1,opt,name=type,enum=bc.DataType" json:"type,omitempty"`
	Bytes []byte      `protobuf:"bytes,2,opt,name=bytes,proto3" json:"bytes,omitempty"`
	Int   int64       `protobuf:"varint,3,opt,name=int" json:"int,omitempty"`
	Tuple []*DataItem `protobuf:"bytes,4,rep,name=tuple" json:"tuple,omitempty"`
}

func (m *DataItem) Reset()                    { *m = DataItem{} }
func (m *DataItem) String() string            { return proto.CompactTextString(m) }
func (*DataItem) ProtoMessage()               {}
func (*DataItem) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

func (m *DataItem) GetType() DataType {
	if m != nil {
		return m.Type
	}
	return DataType_BYTES
}

func (m *DataItem) GetBytes() []byte {
	if m != nil {
		return m.Bytes
	}
	return nil
}

func (m *DataItem) GetInt() int64 {
	if m != nil {
		return m.Int
	}
	return 0
}

func (m *DataItem) GetTuple() []*DataItem {
	if m != nil {
		return m.Tuple
	}
	return nil
}

// BlockHeader is the header of a Block: everything except the block's
// transactions and predicate args.
type BlockHeader struct {
	Version          uint64     `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
	Height           uint64     `protobuf:"varint,2,opt,name=height" json:"height,omitempty"`
	PreviousBlockId  *Hash      `protobuf:"bytes,3,opt,name=previous_block_id,json=previousBlockId" json:"previous_block_id,omitempty"`
	TimestampMs      uint64     `protobuf:"varint,4,opt,name=timestamp_ms,json=timestampMs" json:"timestamp_ms,omitempty"`
	Runlimit         int64      `protobuf:"varint,5,opt,name=runlimit" json:"runlimit,omitempty"`
	RefsCount        int64      `protobuf:"varint,6,opt,name=refs_count,json=refsCount" json:"refs_count,omitempty"`
	TransactionsRoot *Hash      `protobuf:"bytes,7,opt,name=transactions_root,json=transactionsRoot" json:"transactions_root,omitempty"`
	ContractsRoot    *Hash      `protobuf:"bytes,8,opt,name=contracts_root,json=contractsRoot" json:"contracts_root,omitempty"`
	NoncesRoot       *Hash      `protobuf:"bytes,9,opt,name=nonces_root,json=noncesRoot" json:"nonces_root,omitempty"`
	NextPredicate    *Predicate `protobuf:"bytes,10,opt,name=next_predicate,json=nextPredicate" json:"next_predicate,omitempty"`
	// Fields added by future versions of the protocol.
	ExtraFields []*DataItem `protobuf:"bytes,11,rep,name=extra_fields,json=extraFields" json:"extra_fields,omitempty"`
}

func (m *BlockHeader) Reset()                    { *m = BlockHeader{} }
func (m *BlockHeader) String() string            { return proto.CompactTextString(m) }
func (*BlockHeader) ProtoMessage()               {}
func (*BlockHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }

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

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

func (m *BlockHeader) GetPreviousBlockId() *Hash {
	if m != nil {
		return m.PreviousBlockId
	}
	return nil
}

func (m *BlockHeader) GetTimestampMs() uint64 {
	if m != nil {
		return m.TimestampMs
	}
	return 0
}

func (m *BlockHeader) GetRunlimit() int64 {
	if m != nil {
		return m.Runlimit
	}
	return 0
}

func (m *BlockHeader) GetRefsCount() int64 {
	if m != nil {
		return m.RefsCount
	}
	return 0
}

func (m *BlockHeader) GetTransactionsRoot() *Hash {
	if m != nil {
		return m.TransactionsRoot
	}
	return nil
}

func (m *BlockHeader) GetContractsRoot() *Hash {
	if m != nil {
		return m.ContractsRoot
	}
	return nil
}

func (m *BlockHeader) GetNoncesRoot() *Hash {
	if m != nil {
		return m.NoncesRoot
	}
	return nil
}

func (m *BlockHeader) GetNextPredicate() *Predicate {
	if m != nil {
		return m.NextPredicate
	}
	return nil
}

func (m *BlockHeader) GetExtraFields() []*DataItem {
	if m != nil {
		return m.ExtraFields
	}
	return nil
}

// RawTx is a raw transaction, before processing through txvm.
type RawTx struct {
	Version  int64  `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
	Runlimit int64  `protobuf:"varint,2,opt,name=runlimit" json:"runlimit,omitempty"`
	Program  []byte `protobuf:"bytes,3,opt,name=program,proto3" json:"program,omitempty"`
}

func (m *RawTx) Reset()                    { *m = RawTx{} }
func (m *RawTx) String() string            { return proto.CompactTextString(m) }
func (*RawTx) ProtoMessage()               {}
func (*RawTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }

func (m *RawTx) GetVersion() int64 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *RawTx) GetRunlimit() int64 {
	if m != nil {
		return m.Runlimit
	}
	return 0
}

func (m *RawTx) GetProgram() []byte {
	if m != nil {
		return m.Program
	}
	return nil
}

// RawBlock is a raw block.
type RawBlock struct {
	Header       *BlockHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
	Transactions []*RawTx     `protobuf:"bytes,2,rep,name=transactions" json:"transactions,omitempty"`
	Arguments    []*DataItem  `protobuf:"bytes,3,rep,name=arguments" json:"arguments,omitempty"`
}

func (m *RawBlock) Reset()                    { *m = RawBlock{} }
func (m *RawBlock) String() string            { return proto.CompactTextString(m) }
func (*RawBlock) ProtoMessage()               {}
func (*RawBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }

func (m *RawBlock) GetHeader() *BlockHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *RawBlock) GetTransactions() []*RawTx {
	if m != nil {
		return m.Transactions
	}
	return nil
}

func (m *RawBlock) GetArguments() []*DataItem {
	if m != nil {
		return m.Arguments
	}
	return nil
}

func init() {
	proto.RegisterType((*Hash)(nil), "bc.Hash")
	proto.RegisterType((*Predicate)(nil), "bc.Predicate")
	proto.RegisterType((*DataItem)(nil), "bc.DataItem")
	proto.RegisterType((*BlockHeader)(nil), "bc.BlockHeader")
	proto.RegisterType((*RawTx)(nil), "bc.RawTx")
	proto.RegisterType((*RawBlock)(nil), "bc.RawBlock")
	proto.RegisterEnum("bc.DataType", DataType_name, DataType_value)
}

func init() { proto.RegisterFile("bc.proto", fileDescriptor0) }

var fileDescriptor0 = []byte{
	// 594 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xdf, 0x6e, 0xd3, 0x3e,
	0x14, 0xfe, 0x35, 0x49, 0xbb, 0xf6, 0x24, 0xeb, 0x3a, 0xeb, 0x27, 0x64, 0x21, 0x21, 0x95, 0xde,
	0xb0, 0x4d, 0x62, 0x7f, 0xba, 0xf1, 0x02, 0x83, 0x4d, 0x9b, 0x04, 0x68, 0x32, 0x45, 0x08, 0x6e,
	0x22, 0x27, 0xf5, 0xd6, 0x68, 0x4d, 0x1c, 0x6c, 0xa7, 0x6b, 0xdf, 0x80, 0x2b, 0xde, 0x8c, 0x77,
	0x42, 0x3e, 0x49, 0xba, 0x2e, 0x9a, 0xb8, 0xcb, 0xe7, 0xef, 0x3b, 0x7f, 0x7c, 0xce, 0xe7, 0x40,
	0x37, 0x8a, 0x0f, 0x73, 0x25, 0x8d, 0x24, 0x4e, 0x14, 0x8f, 0x2e, 0xc1, 0xbb, 0xe2, 0x7a, 0x46,
	0xfa, 0xe0, 0x2c, 0x8e, 0x69, 0x6b, 0xd8, 0xda, 0xeb, 0x30, 0x67, 0x71, 0x8c, 0xf8, 0x84, 0x3a,
	0x15, 0x3e, 0x41, 0x3c, 0xa6, 0x6e, 0x85, 0xc7, 0x88, 0x4f, 0xa9, 0x57, 0xe1, 0xd3, 0xd1, 0xaf,
	0x16, 0xf4, 0x6e, 0x94, 0x98, 0x26, 0x31, 0x37, 0x82, 0x50, 0xd8, 0x5a, 0x08, 0xa5, 0x13, 0x99,
	0x61, 0x4a, 0x97, 0xd5, 0x90, 0xbc, 0x80, 0xce, 0xcf, 0x42, 0xaa, 0x22, 0xc5, 0xdc, 0x6d, 0x56,
	0x21, 0x1b, 0x91, 0x17, 0xd1, 0xbd, 0x58, 0x69, 0xea, 0x0e, 0xdd, 0xbd, 0x80, 0xd5, 0x90, 0x1c,
	0x41, 0x20, 0xcd, 0x4c, 0xa8, 0xf0, 0x36, 0x11, 0xf3, 0xa9, 0xa6, 0xde, 0xd0, 0xdd, 0xf3, 0xc7,
	0xc1, 0x61, 0x14, 0x1f, 0x7e, 0xe0, 0x86, 0x5f, 0x1b, 0x91, 0x32, 0x1f, 0x15, 0x97, 0x28, 0x18,
	0x2d, 0xa1, 0x5b, 0x13, 0x64, 0x08, 0x9e, 0x59, 0xe5, 0x02, 0xbb, 0xe8, 0x3f, 0x06, 0x4d, 0x56,
	0xb9, 0x60, 0xc8, 0x90, 0xff, 0xa1, 0x1d, 0xad, 0x8c, 0xd0, 0xd8, 0x4f, 0xc0, 0x4a, 0x40, 0x06,
	0xe0, 0x26, 0x99, 0xc1, 0xfb, 0xba, 0xcc, 0x7e, 0x92, 0x11, 0xb4, 0x4d, 0x91, 0xcf, 0xc5, 0xb3,
	0xf5, 0x4b, 0x6a, 0xf4, 0xc7, 0x05, 0xff, 0x7c, 0x2e, 0xe3, 0xfb, 0x2b, 0xc1, 0xa7, 0x42, 0x35,
	0xc7, 0xe0, 0x3d, 0x19, 0xc3, 0x4c, 0x24, 0x77, 0x33, 0x83, 0x65, 0x3d, 0x56, 0x21, 0x72, 0x06,
	0xbb, 0xb9, 0x12, 0x8b, 0x44, 0x16, 0x3a, 0x8c, 0x6c, 0xa6, 0x30, 0x99, 0x62, 0x17, 0xfe, 0xb8,
	0x6b, 0x2b, 0xda, 0x5d, 0xb1, 0x9d, 0x5a, 0x82, 0xb5, 0xae, 0xa7, 0xe4, 0x35, 0x04, 0x26, 0x49,
	0x85, 0x36, 0x3c, 0xcd, 0xc3, 0x54, 0xe3, 0x5a, 0x3c, 0xe6, 0xaf, 0xcf, 0x3e, 0x69, 0xf2, 0x12,
	0xba, 0xaa, 0xc8, 0xe6, 0x49, 0x9a, 0x18, 0xda, 0xc6, 0x5b, 0xad, 0x31, 0x79, 0x05, 0xa0, 0xc4,
	0xad, 0x0e, 0x63, 0x59, 0x64, 0x86, 0x76, 0x90, 0xed, 0xd9, 0x93, 0xf7, 0xf6, 0x80, 0xbc, 0x83,
	0x5d, 0xa3, 0x78, 0xa6, 0x79, 0x6c, 0x12, 0x99, 0xe9, 0x50, 0x49, 0x69, 0xe8, 0x56, 0xa3, 0xa7,
	0xc1, 0xa6, 0x84, 0x49, 0x69, 0xc8, 0x11, 0xf4, 0x63, 0x99, 0x19, 0xc5, 0x63, 0x53, 0xc5, 0x74,
	0x1b, 0x31, 0xdb, 0x6b, 0x1e, 0x03, 0xf6, 0xc1, 0xcf, 0x64, 0x16, 0x8b, 0x4a, 0xdd, 0x6b, 0xa8,
	0xa1, 0x24, 0x51, 0x7a, 0x06, 0xfd, 0x4c, 0x2c, 0x4d, 0x98, 0xd7, 0x8e, 0xa3, 0x80, 0xea, 0x6d,
	0xab, 0x5e, 0xdb, 0x90, 0x6d, 0x5b, 0xd1, 0xa3, 0x2b, 0x8f, 0x20, 0x10, 0x4b, 0xa3, 0x78, 0xed,
	0x24, 0xff, 0x39, 0x27, 0xa1, 0xa2, 0x72, 0xd2, 0x37, 0x68, 0x33, 0xfe, 0x30, 0x59, 0xfe, 0xc3,
	0xcf, 0x9b, 0x73, 0x75, 0x1a, 0x73, 0xb5, 0x9e, 0x56, 0xf2, 0x4e, 0xf1, 0x14, 0x57, 0x68, 0x3d,
	0x5d, 0xc2, 0xd1, 0xef, 0x16, 0x74, 0x19, 0x7f, 0xc0, 0xfd, 0x91, 0x37, 0xd6, 0x0b, 0xd6, 0x2f,
	0x98, 0xdb, 0x1f, 0xef, 0xd8, 0x86, 0x36, 0x6c, 0xc4, 0x2a, 0x9a, 0xbc, 0x85, 0x60, 0x73, 0xca,
	0xd4, 0xc1, 0xfe, 0x7b, 0x56, 0x8e, 0x6d, 0xb2, 0x27, 0x34, 0x39, 0x80, 0x1e, 0x57, 0x77, 0x45,
	0x2a, 0x32, 0x53, 0x3e, 0xaa, 0xe6, 0x5d, 0x1f, 0xe9, 0x83, 0xfd, 0xf2, 0xcd, 0xd8, 0x77, 0x41,
	0x7a, 0xd0, 0x3e, 0xff, 0x3e, 0xb9, 0xf8, 0x32, 0xf8, 0x8f, 0x6c, 0x81, 0x7b, 0xfd, 0x79, 0x32,
	0x68, 0xd9, 0xb3, 0xc9, 0xd7, 0x9b, 0x8f, 0x17, 0x03, 0xe7, 0xdc, 0xfb, 0xe1, 0x44, 0x71, 0xd4,
	0xc1, 0x5f, 0xc8, 0xe9, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x4b, 0x68, 0xac, 0x4e, 0x04,
	0x00, 0x00,
}
