metaBlock.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: metaBlock.proto

package block

import (
	bytes "bytes"
	fmt "fmt"
	github_com_ThotaGopichandThota_gn_core2_data "github.com/ThotaGopichandThota/gn-core2/data"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_big "math/big"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// PeerAction type represents the possible events that a node can trigger for the metachain to notarize
type PeerAction int32

const (
	InvalidAction      PeerAction = 0
	PeerRegistration   PeerAction = 1
	PeerUnstaking      PeerAction = 2
	PeerDeregistration PeerAction = 3
	PeerJailed         PeerAction = 4
	PeerUnJailed       PeerAction = 5
	PeerSlashed        PeerAction = 6
	PeerReStake        PeerAction = 7
)

var PeerAction_name = map[int32]string{
	0: "InvalidAction",
	1: "PeerRegistration",
	2: "PeerUnstaking",
	3: "PeerDeregistration",
	4: "PeerJailed",
	5: "PeerUnJailed",
	6: "PeerSlashed",
	7: "PeerReStake",
}

var PeerAction_value = map[string]int32{
	"InvalidAction":      0,
	"PeerRegistration":   1,
	"PeerUnstaking":      2,
	"PeerDeregistration": 3,
	"PeerJailed":         4,
	"PeerUnJailed":       5,
	"PeerSlashed":        6,
	"PeerReStake":        7,
}

func (PeerAction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_87b91ab531130b2b, []int{0}
}

// PeerData holds information about actions taken by a peer:
//   - a peer can register with an amount to become a validator
//   - a peer can choose to deregister and get back the deposited value
type PeerData struct {
	Address     []byte        `protobuf:"bytes,1,opt,name=Address,proto3" json:"address,omitempty"`
	PublicKey   []byte        `protobuf:"bytes,2,opt,name=PublicKey,proto3" json:"publicKey,omitempty"`
	Action      PeerAction    `protobuf:"varint,3,opt,name=Action,proto3,enum=proto.PeerAction" json:"action"`
	TimeStamp   uint64        `protobuf:"varint,4,opt,name=TimeStamp,proto3" json:"timeStamp,omitempty"`
	ValueChange *math_big.Int `protobuf:"bytes,5,opt,name=ValueChange,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"valueChange,omitempty"`
}

func (m *PeerData) Reset()      { *m = PeerData{} }
func (*PeerData) ProtoMessage() {}
func (*PeerData) Descriptor() ([]byte, []int) {
	return fileDescriptor_87b91ab531130b2b, []int{0}
}
func (m *PeerData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PeerData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *PeerData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PeerData.Merge(m, src)
}
func (m *PeerData) XXX_Size() int {
	return m.Size()
}
func (m *PeerData) XXX_DiscardUnknown() {
	xxx_messageInfo_PeerData.DiscardUnknown(m)
}

var xxx_messageInfo_PeerData proto.InternalMessageInfo

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

func (m *PeerData) GetPublicKey() []byte {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

func (m *PeerData) GetAction() PeerAction {
	if m != nil {
		return m.Action
	}
	return InvalidAction
}

func (m *PeerData) GetTimeStamp() uint64 {
	if m != nil {
		return m.TimeStamp
	}
	return 0
}

func (m *PeerData) GetValueChange() *math_big.Int {
	if m != nil {
		return m.ValueChange
	}
	return nil
}

// ShardData holds the block information sent by the shards to the metachain
type ShardData struct {
	HeaderHash            []byte            `protobuf:"bytes,2,opt,name=HeaderHash,proto3" json:"headerHash,omitempty"`
	ShardMiniBlockHeaders []MiniBlockHeader `protobuf:"bytes,3,rep,name=ShardMiniBlockHeaders,proto3" json:"shardMiniBlockHeaders"`
	PrevRandSeed          []byte            `protobuf:"bytes,4,opt,name=PrevRandSeed,proto3" json:"prevRandSeed,omitempty"`
	PubKeysBitmap         []byte            `protobuf:"bytes,5,opt,name=PubKeysBitmap,proto3" json:"pubKeysBitmap,omitempty"`
	Signature             []byte            `protobuf:"bytes,6,opt,name=Signature,proto3" json:"signature,omitempty"`
	Round                 uint64            `protobuf:"varint,8,opt,name=Round,proto3" json:"round"`
	PrevHash              []byte            `protobuf:"bytes,9,opt,name=PrevHash,proto3" json:"prevHash,omitempty"`
	Nonce                 uint64            `protobuf:"varint,10,opt,name=Nonce,proto3" json:"nonce"`
	AccumulatedFees       *math_big.Int     `protobuf:"bytes,12,opt,name=AccumulatedFees,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"accumulatedFees,omitempty"`
	DeveloperFees         *math_big.Int     `protobuf:"bytes,14,opt,name=DeveloperFees,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"developerFees,omitempty"`
	NumPendingMiniBlocks  uint32            `protobuf:"varint,11,opt,name=NumPendingMiniBlocks,proto3" json:"numPendingMiniBlocks"`
	LastIncludedMetaNonce uint64            `protobuf:"varint,13,opt,name=LastIncludedMetaNonce,proto3" json:"lastIncludedMetaNonce"`
	ShardID               uint32            `protobuf:"varint,1,opt,name=ShardID,proto3" json:"shardID"`
	TxCount               uint32            `protobuf:"varint,7,opt,name=TxCount,proto3" json:"txCount"`
}

func (m *ShardData) Reset()      { *m = ShardData{} }
func (*ShardData) ProtoMessage() {}
func (*ShardData) Descriptor() ([]byte, []int) {
	return fileDescriptor_87b91ab531130b2b, []int{1}
}
func (m *ShardData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShardData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ShardData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShardData.Merge(m, src)
}
func (m *ShardData) XXX_Size() int {
	return m.Size()
}
func (m *ShardData) XXX_DiscardUnknown() {
	xxx_messageInfo_ShardData.DiscardUnknown(m)
}

var xxx_messageInfo_ShardData proto.InternalMessageInfo

func (m *ShardData) GetHeaderHash() []byte {
	if m != nil {
		return m.HeaderHash
	}
	return nil
}

func (m *ShardData) GetShardMiniBlockHeaders() []MiniBlockHeader {
	if m != nil {
		return m.ShardMiniBlockHeaders
	}
	return nil
}

func (m *ShardData) GetPrevRandSeed() []byte {
	if m != nil {
		return m.PrevRandSeed
	}
	return nil
}

func (m *ShardData) GetPubKeysBitmap() []byte {
	if m != nil {
		return m.PubKeysBitmap
	}
	return nil
}

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

func (m *ShardData) GetRound() uint64 {
	if m != nil {
		return m.Round
	}
	return 0
}

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

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

func (m *ShardData) GetAccumulatedFees() *math_big.Int {
	if m != nil {
		return m.AccumulatedFees
	}
	return nil
}

func (m *ShardData) GetDeveloperFees() *math_big.Int {
	if m != nil {
		return m.DeveloperFees
	}
	return nil
}

func (m *ShardData) GetNumPendingMiniBlocks() uint32 {
	if m != nil {
		return m.NumPendingMiniBlocks
	}
	return 0
}

func (m *ShardData) GetLastIncludedMetaNonce() uint64 {
	if m != nil {
		return m.LastIncludedMetaNonce
	}
	return 0
}

func (m *ShardData) GetShardID() uint32 {
	if m != nil {
		return m.ShardID
	}
	return 0
}

func (m *ShardData) GetTxCount() uint32 {
	if m != nil {
		return m.TxCount
	}
	return 0
}

// EpochStartShardData hold the last finalized headers hash and state root hash
type EpochStartShardData struct {
	ShardID                 uint32            `protobuf:"varint,1,opt,name=ShardID,proto3" json:"shardID"`
	Epoch                   uint32            `protobuf:"varint,9,opt,name=Epoch,proto3" json:"epoch"`
	Round                   uint64            `protobuf:"varint,7,opt,name=Round,proto3" json:"round"`
	Nonce                   uint64            `protobuf:"varint,8,opt,name=Nonce,proto3" json:"nonce"`
	HeaderHash              []byte            `protobuf:"bytes,2,opt,name=HeaderHash,proto3" json:"headerHash,omitempty"`
	RootHash                []byte            `protobuf:"bytes,3,opt,name=RootHash,proto3" json:"rootHash,omitempty"`
	ScheduledRootHash       []byte            `protobuf:"bytes,10,opt,name=ScheduledRootHash,proto3" json:"scheduledRootHash,omitempty"`
	FirstPendingMetaBlock   []byte            `protobuf:"bytes,4,opt,name=FirstPendingMetaBlock,proto3" json:"firstPendingMetaBlock,omitempty"`
	LastFinishedMetaBlock   []byte            `protobuf:"bytes,5,opt,name=LastFinishedMetaBlock,proto3" json:"lastFinishedMetaBlock,omitempty"`
	PendingMiniBlockHeaders []MiniBlockHeader `protobuf:"bytes,6,rep,name=PendingMiniBlockHeaders,proto3" json:"pendingMiniBlockHeaders"`
}

func (m *EpochStartShardData) Reset()      { *m = EpochStartShardData{} }
func (*EpochStartShardData) ProtoMessage() {}
func (*EpochStartShardData) Descriptor() ([]byte, []int) {
	return fileDescriptor_87b91ab531130b2b, []int{2}
}
func (m *EpochStartShardData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EpochStartShardData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *EpochStartShardData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EpochStartShardData.Merge(m, src)
}
func (m *EpochStartShardData) XXX_Size() int {
	return m.Size()
}
func (m *EpochStartShardData) XXX_DiscardUnknown() {
	xxx_messageInfo_EpochStartShardData.DiscardUnknown(m)
}

var xxx_messageInfo_EpochStartShardData proto.InternalMessageInfo

func (m *EpochStartShardData) GetShardID() uint32 {
	if m != nil {
		return m.ShardID
	}
	return 0
}

func (m *EpochStartShardData) GetEpoch() uint32 {
	if m != nil {
		return m.Epoch
	}
	return 0
}

func (m *EpochStartShardData) GetRound() uint64 {
	if m != nil {
		return m.Round
	}
	return 0
}

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

func (m *EpochStartShardData) GetHeaderHash() []byte {
	if m != nil {
		return m.HeaderHash
	}
	return nil
}

func (m *EpochStartShardData) GetRootHash() []byte {
	if m != nil {
		return m.RootHash
	}
	return nil
}

func (m *EpochStartShardData) GetScheduledRootHash() []byte {
	if m != nil {
		return m.ScheduledRootHash
	}
	return nil
}

func (m *EpochStartShardData) GetFirstPendingMetaBlock() []byte {
	if m != nil {
		return m.FirstPendingMetaBlock
	}
	return nil
}

func (m *EpochStartShardData) GetLastFinishedMetaBlock() []byte {
	if m != nil {
		return m.LastFinishedMetaBlock
	}
	return nil
}

func (m *EpochStartShardData) GetPendingMiniBlockHeaders() []MiniBlockHeader {
	if m != nil {
		return m.PendingMiniBlockHeaders
	}
	return nil
}

// Economics holds the block information for total supply and rewards
type Economics struct {
	TotalSupply                      *math_big.Int `protobuf:"bytes,1,opt,name=TotalSupply,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"totalSupply,omitempty"`
	TotalToDistribute                *math_big.Int `protobuf:"bytes,2,opt,name=TotalToDistribute,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"totalToDistribute,omitempty"`
	TotalNewlyMinted                 *math_big.Int `protobuf:"bytes,3,opt,name=TotalNewlyMinted,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"totalNewlyMinted,omitempty"`
	RewardsPerBlock                  *math_big.Int `protobuf:"bytes,4,opt,name=RewardsPerBlock,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"rewardsPerBlock,omitempty"`
	RewardsForProtocolSustainability *math_big.Int `protobuf:"bytes,5,opt,name=RewardsForProtocolSustainability,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"rewardsForProtocolSustainability,omitempty"`
	NodePrice                        *math_big.Int `protobuf:"bytes,6,opt,name=NodePrice,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"nodePrice,omitempty"`
	PrevEpochStartRound              uint64        `protobuf:"varint,7,opt,name=PrevEpochStartRound,proto3" json:"prevEpochStartRound"`
	PrevEpochStartHash               []byte        `protobuf:"bytes,8,opt,name=PrevEpochStartHash,proto3" json:"prevEpochStartHash,omitempty"`
}

func (m *Economics) Reset()      { *m = Economics{} }
func (*Economics) ProtoMessage() {}
func (*Economics) Descriptor() ([]byte, []int) {
	return fileDescriptor_87b91ab531130b2b, []int{3}
}
func (m *Economics) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Economics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Economics) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Economics.Merge(m, src)
}
func (m *Economics) XXX_Size() int {
	return m.Size()
}
func (m *Economics) XXX_DiscardUnknown() {
	xxx_messageInfo_Economics.DiscardUnknown(m)
}

var xxx_messageInfo_Economics proto.InternalMessageInfo

func (m *Economics) GetTotalSupply() *math_big.Int {
	if m != nil {
		return m.TotalSupply
	}
	return nil
}

func (m *Economics) GetTotalToDistribute() *math_big.Int {
	if m != nil {
		return m.TotalToDistribute
	}
	return nil
}

func (m *Economics) GetTotalNewlyMinted() *math_big.Int {
	if m != nil {
		return m.TotalNewlyMinted
	}
	return nil
}

func (m *Economics) GetRewardsPerBlock() *math_big.Int {
	if m != nil {
		return m.RewardsPerBlock
	}
	return nil
}

func (m *Economics) GetRewardsForProtocolSustainability() *math_big.Int {
	if m != nil {
		return m.RewardsForProtocolSustainability
	}
	return nil
}

func (m *Economics) GetNodePrice() *math_big.Int {
	if m != nil {
		return m.NodePrice
	}
	return nil
}

func (m *Economics) GetPrevEpochStartRound() uint64 {
	if m != nil {
		return m.PrevEpochStartRound
	}
	return 0
}

func (m *Economics) GetPrevEpochStartHash() []byte {
	if m != nil {
		return m.PrevEpochStartHash
	}
	return nil
}

// EpochStart holds the block information for end-of-epoch
type EpochStart struct {
	LastFinalizedHeaders []EpochStartShardData `protobuf:"bytes,1,rep,name=LastFinalizedHeaders,proto3" json:"lastFinalizedHeaders"`
	Economics            Economics             `protobuf:"bytes,2,opt,name=Economics,proto3" json:"economics"`
}

func (m *EpochStart) Reset()      { *m = EpochStart{} }
func (*EpochStart) ProtoMessage() {}
func (*EpochStart) Descriptor() ([]byte, []int) {
	return fileDescriptor_87b91ab531130b2b, []int{4}
}
func (m *EpochStart) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EpochStart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *EpochStart) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EpochStart.Merge(m, src)
}
func (m *EpochStart) XXX_Size() int {
	return m.Size()
}
func (m *EpochStart) XXX_DiscardUnknown() {
	xxx_messageInfo_EpochStart.DiscardUnknown(m)
}

var xxx_messageInfo_EpochStart proto.InternalMessageInfo

func (m *EpochStart) GetLastFinalizedHeaders() []EpochStartShardData {
	if m != nil {
		return m.LastFinalizedHeaders
	}
	return nil
}

func (m *EpochStart) GetEconomics() Economics {
	if m != nil {
		return m.Economics
	}
	return Economics{}
}

// MetaBlock holds the data that will be saved to the metachain each round
type MetaBlock struct {
	Nonce                  uint64            `protobuf:"varint,1,opt,name=Nonce,proto3" json:"nonce"`
	Epoch                  uint32            `protobuf:"varint,2,opt,name=Epoch,proto3" json:"epoch"`
	Round                  uint64            `protobuf:"varint,3,opt,name=Round,proto3" json:"round"`
	TimeStamp              uint64            `protobuf:"varint,4,opt,name=TimeStamp,proto3" json:"timeStamp,omitempty"`
	ShardInfo              []ShardData       `protobuf:"bytes,5,rep,name=ShardInfo,proto3" json:"shardInfo"`
	PeerInfo               []PeerData        `protobuf:"bytes,6,rep,name=PeerInfo,proto3" json:"peerInfo"`
	Signature              []byte            `protobuf:"bytes,7,opt,name=Signature,proto3" json:"signature,omitempty"`
	LeaderSignature        []byte            `protobuf:"bytes,8,opt,name=LeaderSignature,proto3" json:"leaderSignature,omitempty"`
	PubKeysBitmap          []byte            `protobuf:"bytes,9,opt,name=PubKeysBitmap,proto3" json:"pubKeysBitmap,omitempty"`
	PrevHash               []byte            `protobuf:"bytes,10,opt,name=PrevHash,proto3" json:"prevHash,omitempty"`
	PrevRandSeed           []byte            `protobuf:"bytes,11,opt,name=PrevRandSeed,proto3" json:"prevRandSeed,omitempty"`
	RandSeed               []byte            `protobuf:"bytes,12,opt,name=RandSeed,proto3" json:"randSeed,omitempty"`
	RootHash               []byte            `protobuf:"bytes,13,opt,name=RootHash,proto3" json:"rootHash,omitempty"`
	ValidatorStatsRootHash []byte            `protobuf:"bytes,14,opt,name=ValidatorStatsRootHash,proto3" json:"validatorStatsRootHash,omitempty"`
	MiniBlockHeaders       []MiniBlockHeader `protobuf:"bytes,16,rep,name=MiniBlockHeaders,proto3" json:"miniBlockHeaders"`
	ReceiptsHash           []byte            `protobuf:"bytes,17,opt,name=ReceiptsHash,proto3" json:"receiptsHash,omitempty"`
	EpochStart             EpochStart        `protobuf:"bytes,18,opt,name=EpochStart,proto3" json:"epochStart,omitempty"`
	ChainID                []byte            `protobuf:"bytes,19,opt,name=ChainID,proto3" json:"chainID,omitempty"`
	SoftwareVersion        []byte            `protobuf:"bytes,20,opt,name=SoftwareVersion,proto3" json:"softwareVersion,omitempty"`
	AccumulatedFees        *math_big.Int     `protobuf:"bytes,21,opt,name=AccumulatedFees,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"accumulatedFees,omitempty"`
	AccumulatedFeesInEpoch *math_big.Int     `protobuf:"bytes,22,opt,name=AccumulatedFeesInEpoch,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"accumulatedFeesInEpoch,omitempty"`
	DeveloperFees          *math_big.Int     `protobuf:"bytes,23,opt,name=DeveloperFees,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"developerFees,omitempty"`
	DevFeesInEpoch         *math_big.Int     `protobuf:"bytes,24,opt,name=DevFeesInEpoch,proto3,casttypewith=math/big.Int;github.com/ThotaGopichandThota/gn-core2/data.BigIntCaster" json:"devFeesInEpoch,omitempty"`
	TxCount                uint32            `protobuf:"varint,25,opt,name=TxCount,proto3" json:"txCount"`
	Reserved               []byte            `protobuf:"bytes,26,opt,name=Reserved,proto3" json:"reserved,omitempty"`
}

func (m *MetaBlock) Reset()      { *m = MetaBlock{} }
func (*MetaBlock) ProtoMessage() {}
func (*MetaBlock) Descriptor() ([]byte, []int) {
	return fileDescriptor_87b91ab531130b2b, []int{5}
}
func (m *MetaBlock) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MetaBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *MetaBlock) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetaBlock.Merge(m, src)
}
func (m *MetaBlock) XXX_Size() int {
	return m.Size()
}
func (m *MetaBlock) XXX_DiscardUnknown() {
	xxx_messageInfo_MetaBlock.DiscardUnknown(m)
}

var xxx_messageInfo_MetaBlock proto.InternalMessageInfo

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

func (m *MetaBlock) GetEpoch() uint32 {
	if m != nil {
		return m.Epoch
	}
	return 0
}

func (m *MetaBlock) GetRound() uint64 {
	if m != nil {
		return m.Round
	}
	return 0
}

func (m *MetaBlock) GetTimeStamp() uint64 {
	if m != nil {
		return m.TimeStamp
	}
	return 0
}

func (m *MetaBlock) GetShardInfo() []ShardData {
	if m != nil {
		return m.ShardInfo
	}
	return nil
}

func (m *MetaBlock) GetPeerInfo() []PeerData {
	if m != nil {
		return m.PeerInfo
	}
	return nil
}

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

func (m *MetaBlock) GetLeaderSignature() []byte {
	if m != nil {
		return m.LeaderSignature
	}
	return nil
}

func (m *MetaBlock) GetPubKeysBitmap() []byte {
	if m != nil {
		return m.PubKeysBitmap
	}
	return nil
}

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

func (m *MetaBlock) GetPrevRandSeed() []byte {
	if m != nil {
		return m.PrevRandSeed
	}
	return nil
}

func (m *MetaBlock) GetRandSeed() []byte {
	if m != nil {
		return m.RandSeed
	}
	return nil
}

func (m *MetaBlock) GetRootHash() []byte {
	if m != nil {
		return m.RootHash
	}
	return nil
}

func (m *MetaBlock) GetValidatorStatsRootHash() []byte {
	if m != nil {
		return m.ValidatorStatsRootHash
	}
	return nil
}

func (m *MetaBlock) GetMiniBlockHeaders() []MiniBlockHeader {
	if m != nil {
		return m.MiniBlockHeaders
	}
	return nil
}

func (m *MetaBlock) GetReceiptsHash() []byte {
	if m != nil {
		return m.ReceiptsHash
	}
	return nil
}

func (m *MetaBlock) GetEpochStart() EpochStart {
	if m != nil {
		return m.EpochStart
	}
	return EpochStart{}
}

func (m *MetaBlock) GetChainID() []byte {
	if m != nil {
		return m.ChainID
	}
	return nil
}

func (m *MetaBlock) GetSoftwareVersion() []byte {
	if m != nil {
		return m.SoftwareVersion
	}
	return nil
}

func (m *MetaBlock) GetAccumulatedFees() *math_big.Int {
	if m != nil {
		return m.AccumulatedFees
	}
	return nil
}

func (m *MetaBlock) GetAccumulatedFeesInEpoch() *math_big.Int {
	if m != nil {
		return m.AccumulatedFeesInEpoch
	}
	return nil
}

func (m *MetaBlock) GetDeveloperFees() *math_big.Int {
	if m != nil {
		return m.DeveloperFees
	}
	return nil
}

func (m *MetaBlock) GetDevFeesInEpoch() *math_big.Int {
	if m != nil {
		return m.DevFeesInEpoch
	}
	return nil
}

func (m *MetaBlock) GetTxCount() uint32 {
	if m != nil {
		return m.TxCount
	}
	return 0
}

func (m *MetaBlock) GetReserved() []byte {
	if m != nil {
		return m.Reserved
	}
	return nil
}

func init() {
	proto.RegisterEnum("proto.PeerAction", PeerAction_name, PeerAction_value)
	proto.RegisterType((*PeerData)(nil), "proto.PeerData")
	proto.RegisterType((*ShardData)(nil), "proto.ShardData")
	proto.RegisterType((*EpochStartShardData)(nil), "proto.EpochStartShardData")
	proto.RegisterType((*Economics)(nil), "proto.Economics")
	proto.RegisterType((*EpochStart)(nil), "proto.EpochStart")
	proto.RegisterType((*MetaBlock)(nil), "proto.MetaBlock")
}

func init() { proto.RegisterFile("metaBlock.proto", fileDescriptor_87b91ab531130b2b) }

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

func (x PeerAction) String() string {
	s, ok := PeerAction_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *PeerData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PeerData)
	if !ok {
		that2, ok := that.(PeerData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Address, that1.Address) {
		return false
	}
	if !bytes.Equal(this.PublicKey, that1.PublicKey) {
		return false
	}
	if this.Action != that1.Action {
		return false
	}
	if this.TimeStamp != that1.TimeStamp {
		return false
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.ValueChange, that1.ValueChange) {
			return false
		}
	}
	return true
}
func (this *ShardData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ShardData)
	if !ok {
		that2, ok := that.(ShardData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.HeaderHash, that1.HeaderHash) {
		return false
	}
	if len(this.ShardMiniBlockHeaders) != len(that1.ShardMiniBlockHeaders) {
		return false
	}
	for i := range this.ShardMiniBlockHeaders {
		if !this.ShardMiniBlockHeaders[i].Equal(&that1.ShardMiniBlockHeaders[i]) {
			return false
		}
	}
	if !bytes.Equal(this.PrevRandSeed, that1.PrevRandSeed) {
		return false
	}
	if !bytes.Equal(this.PubKeysBitmap, that1.PubKeysBitmap) {
		return false
	}
	if !bytes.Equal(this.Signature, that1.Signature) {
		return false
	}
	if this.Round != that1.Round {
		return false
	}
	if !bytes.Equal(this.PrevHash, that1.PrevHash) {
		return false
	}
	if this.Nonce != that1.Nonce {
		return false
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.AccumulatedFees, that1.AccumulatedFees) {
			return false
		}
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.DeveloperFees, that1.DeveloperFees) {
			return false
		}
	}
	if this.NumPendingMiniBlocks != that1.NumPendingMiniBlocks {
		return false
	}
	if this.LastIncludedMetaNonce != that1.LastIncludedMetaNonce {
		return false
	}
	if this.ShardID != that1.ShardID {
		return false
	}
	if this.TxCount != that1.TxCount {
		return false
	}
	return true
}
func (this *EpochStartShardData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EpochStartShardData)
	if !ok {
		that2, ok := that.(EpochStartShardData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ShardID != that1.ShardID {
		return false
	}
	if this.Epoch != that1.Epoch {
		return false
	}
	if this.Round != that1.Round {
		return false
	}
	if this.Nonce != that1.Nonce {
		return false
	}
	if !bytes.Equal(this.HeaderHash, that1.HeaderHash) {
		return false
	}
	if !bytes.Equal(this.RootHash, that1.RootHash) {
		return false
	}
	if !bytes.Equal(this.ScheduledRootHash, that1.ScheduledRootHash) {
		return false
	}
	if !bytes.Equal(this.FirstPendingMetaBlock, that1.FirstPendingMetaBlock) {
		return false
	}
	if !bytes.Equal(this.LastFinishedMetaBlock, that1.LastFinishedMetaBlock) {
		return false
	}
	if len(this.PendingMiniBlockHeaders) != len(that1.PendingMiniBlockHeaders) {
		return false
	}
	for i := range this.PendingMiniBlockHeaders {
		if !this.PendingMiniBlockHeaders[i].Equal(&that1.PendingMiniBlockHeaders[i]) {
			return false
		}
	}
	return true
}
func (this *Economics) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Economics)
	if !ok {
		that2, ok := that.(Economics)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.TotalSupply, that1.TotalSupply) {
			return false
		}
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.TotalToDistribute, that1.TotalToDistribute) {
			return false
		}
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.TotalNewlyMinted, that1.TotalNewlyMinted) {
			return false
		}
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.RewardsPerBlock, that1.RewardsPerBlock) {
			return false
		}
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.RewardsForProtocolSustainability, that1.RewardsForProtocolSustainability) {
			return false
		}
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.NodePrice, that1.NodePrice) {
			return false
		}
	}
	if this.PrevEpochStartRound != that1.PrevEpochStartRound {
		return false
	}
	if !bytes.Equal(this.PrevEpochStartHash, that1.PrevEpochStartHash) {
		return false
	}
	return true
}
func (this *EpochStart) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EpochStart)
	if !ok {
		that2, ok := that.(EpochStart)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.LastFinalizedHeaders) != len(that1.LastFinalizedHeaders) {
		return false
	}
	for i := range this.LastFinalizedHeaders {
		if !this.LastFinalizedHeaders[i].Equal(&that1.LastFinalizedHeaders[i]) {
			return false
		}
	}
	if !this.Economics.Equal(&that1.Economics) {
		return false
	}
	return true
}
func (this *MetaBlock) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetaBlock)
	if !ok {
		that2, ok := that.(MetaBlock)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Nonce != that1.Nonce {
		return false
	}
	if this.Epoch != that1.Epoch {
		return false
	}
	if this.Round != that1.Round {
		return false
	}
	if this.TimeStamp != that1.TimeStamp {
		return false
	}
	if len(this.ShardInfo) != len(that1.ShardInfo) {
		return false
	}
	for i := range this.ShardInfo {
		if !this.ShardInfo[i].Equal(&that1.ShardInfo[i]) {
			return false
		}
	}
	if len(this.PeerInfo) != len(that1.PeerInfo) {
		return false
	}
	for i := range this.PeerInfo {
		if !this.PeerInfo[i].Equal(&that1.PeerInfo[i]) {
			return false
		}
	}
	if !bytes.Equal(this.Signature, that1.Signature) {
		return false
	}
	if !bytes.Equal(this.LeaderSignature, that1.LeaderSignature) {
		return false
	}
	if !bytes.Equal(this.PubKeysBitmap, that1.PubKeysBitmap) {
		return false
	}
	if !bytes.Equal(this.PrevHash, that1.PrevHash) {
		return false
	}
	if !bytes.Equal(this.PrevRandSeed, that1.PrevRandSeed) {
		return false
	}
	if !bytes.Equal(this.RandSeed, that1.RandSeed) {
		return false
	}
	if !bytes.Equal(this.RootHash, that1.RootHash) {
		return false
	}
	if !bytes.Equal(this.ValidatorStatsRootHash, that1.ValidatorStatsRootHash) {
		return false
	}
	if len(this.MiniBlockHeaders) != len(that1.MiniBlockHeaders) {
		return false
	}
	for i := range this.MiniBlockHeaders {
		if !this.MiniBlockHeaders[i].Equal(&that1.MiniBlockHeaders[i]) {
			return false
		}
	}
	if !bytes.Equal(this.ReceiptsHash, that1.ReceiptsHash) {
		return false
	}
	if !this.EpochStart.Equal(&that1.EpochStart) {
		return false
	}
	if !bytes.Equal(this.ChainID, that1.ChainID) {
		return false
	}
	if !bytes.Equal(this.SoftwareVersion, that1.SoftwareVersion) {
		return false
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.AccumulatedFees, that1.AccumulatedFees) {
			return false
		}
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.AccumulatedFeesInEpoch, that1.AccumulatedFeesInEpoch) {
			return false
		}
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.DeveloperFees, that1.DeveloperFees) {
			return false
		}
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		if !__caster.Equal(this.DevFeesInEpoch, that1.DevFeesInEpoch) {
			return false
		}
	}
	if this.TxCount != that1.TxCount {
		return false
	}
	if !bytes.Equal(this.Reserved, that1.Reserved) {
		return false
	}
	return true
}
func (this *PeerData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&block.PeerData{")
	s = append(s, "Address: "+fmt.Sprintf("%#v", this.Address)+",\n")
	s = append(s, "PublicKey: "+fmt.Sprintf("%#v", this.PublicKey)+",\n")
	s = append(s, "Action: "+fmt.Sprintf("%#v", this.Action)+",\n")
	s = append(s, "TimeStamp: "+fmt.Sprintf("%#v", this.TimeStamp)+",\n")
	s = append(s, "ValueChange: "+fmt.Sprintf("%#v", this.ValueChange)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ShardData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 18)
	s = append(s, "&block.ShardData{")
	s = append(s, "HeaderHash: "+fmt.Sprintf("%#v", this.HeaderHash)+",\n")
	if this.ShardMiniBlockHeaders != nil {
		vs := make([]MiniBlockHeader, len(this.ShardMiniBlockHeaders))
		for i := range vs {
			vs[i] = this.ShardMiniBlockHeaders[i]
		}
		s = append(s, "ShardMiniBlockHeaders: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "PrevRandSeed: "+fmt.Sprintf("%#v", this.PrevRandSeed)+",\n")
	s = append(s, "PubKeysBitmap: "+fmt.Sprintf("%#v", this.PubKeysBitmap)+",\n")
	s = append(s, "Signature: "+fmt.Sprintf("%#v", this.Signature)+",\n")
	s = append(s, "Round: "+fmt.Sprintf("%#v", this.Round)+",\n")
	s = append(s, "PrevHash: "+fmt.Sprintf("%#v", this.PrevHash)+",\n")
	s = append(s, "Nonce: "+fmt.Sprintf("%#v", this.Nonce)+",\n")
	s = append(s, "AccumulatedFees: "+fmt.Sprintf("%#v", this.AccumulatedFees)+",\n")
	s = append(s, "DeveloperFees: "+fmt.Sprintf("%#v", this.DeveloperFees)+",\n")
	s = append(s, "NumPendingMiniBlocks: "+fmt.Sprintf("%#v", this.NumPendingMiniBlocks)+",\n")
	s = append(s, "LastIncludedMetaNonce: "+fmt.Sprintf("%#v", this.LastIncludedMetaNonce)+",\n")
	s = append(s, "ShardID: "+fmt.Sprintf("%#v", this.ShardID)+",\n")
	s = append(s, "TxCount: "+fmt.Sprintf("%#v", this.TxCount)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EpochStartShardData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 14)
	s = append(s, "&block.EpochStartShardData{")
	s = append(s, "ShardID: "+fmt.Sprintf("%#v", this.ShardID)+",\n")
	s = append(s, "Epoch: "+fmt.Sprintf("%#v", this.Epoch)+",\n")
	s = append(s, "Round: "+fmt.Sprintf("%#v", this.Round)+",\n")
	s = append(s, "Nonce: "+fmt.Sprintf("%#v", this.Nonce)+",\n")
	s = append(s, "HeaderHash: "+fmt.Sprintf("%#v", this.HeaderHash)+",\n")
	s = append(s, "RootHash: "+fmt.Sprintf("%#v", this.RootHash)+",\n")
	s = append(s, "ScheduledRootHash: "+fmt.Sprintf("%#v", this.ScheduledRootHash)+",\n")
	s = append(s, "FirstPendingMetaBlock: "+fmt.Sprintf("%#v", this.FirstPendingMetaBlock)+",\n")
	s = append(s, "LastFinishedMetaBlock: "+fmt.Sprintf("%#v", this.LastFinishedMetaBlock)+",\n")
	if this.PendingMiniBlockHeaders != nil {
		vs := make([]MiniBlockHeader, len(this.PendingMiniBlockHeaders))
		for i := range vs {
			vs[i] = this.PendingMiniBlockHeaders[i]
		}
		s = append(s, "PendingMiniBlockHeaders: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Economics) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&block.Economics{")
	s = append(s, "TotalSupply: "+fmt.Sprintf("%#v", this.TotalSupply)+",\n")
	s = append(s, "TotalToDistribute: "+fmt.Sprintf("%#v", this.TotalToDistribute)+",\n")
	s = append(s, "TotalNewlyMinted: "+fmt.Sprintf("%#v", this.TotalNewlyMinted)+",\n")
	s = append(s, "RewardsPerBlock: "+fmt.Sprintf("%#v", this.RewardsPerBlock)+",\n")
	s = append(s, "RewardsForProtocolSustainability: "+fmt.Sprintf("%#v", this.RewardsForProtocolSustainability)+",\n")
	s = append(s, "NodePrice: "+fmt.Sprintf("%#v", this.NodePrice)+",\n")
	s = append(s, "PrevEpochStartRound: "+fmt.Sprintf("%#v", this.PrevEpochStartRound)+",\n")
	s = append(s, "PrevEpochStartHash: "+fmt.Sprintf("%#v", this.PrevEpochStartHash)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EpochStart) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&block.EpochStart{")
	if this.LastFinalizedHeaders != nil {
		vs := make([]EpochStartShardData, len(this.LastFinalizedHeaders))
		for i := range vs {
			vs[i] = this.LastFinalizedHeaders[i]
		}
		s = append(s, "LastFinalizedHeaders: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "Economics: "+strings.Replace(this.Economics.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MetaBlock) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 29)
	s = append(s, "&block.MetaBlock{")
	s = append(s, "Nonce: "+fmt.Sprintf("%#v", this.Nonce)+",\n")
	s = append(s, "Epoch: "+fmt.Sprintf("%#v", this.Epoch)+",\n")
	s = append(s, "Round: "+fmt.Sprintf("%#v", this.Round)+",\n")
	s = append(s, "TimeStamp: "+fmt.Sprintf("%#v", this.TimeStamp)+",\n")
	if this.ShardInfo != nil {
		vs := make([]ShardData, len(this.ShardInfo))
		for i := range vs {
			vs[i] = this.ShardInfo[i]
		}
		s = append(s, "ShardInfo: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	if this.PeerInfo != nil {
		vs := make([]PeerData, len(this.PeerInfo))
		for i := range vs {
			vs[i] = this.PeerInfo[i]
		}
		s = append(s, "PeerInfo: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "Signature: "+fmt.Sprintf("%#v", this.Signature)+",\n")
	s = append(s, "LeaderSignature: "+fmt.Sprintf("%#v", this.LeaderSignature)+",\n")
	s = append(s, "PubKeysBitmap: "+fmt.Sprintf("%#v", this.PubKeysBitmap)+",\n")
	s = append(s, "PrevHash: "+fmt.Sprintf("%#v", this.PrevHash)+",\n")
	s = append(s, "PrevRandSeed: "+fmt.Sprintf("%#v", this.PrevRandSeed)+",\n")
	s = append(s, "RandSeed: "+fmt.Sprintf("%#v", this.RandSeed)+",\n")
	s = append(s, "RootHash: "+fmt.Sprintf("%#v", this.RootHash)+",\n")
	s = append(s, "ValidatorStatsRootHash: "+fmt.Sprintf("%#v", this.ValidatorStatsRootHash)+",\n")
	if this.MiniBlockHeaders != nil {
		vs := make([]MiniBlockHeader, len(this.MiniBlockHeaders))
		for i := range vs {
			vs[i] = this.MiniBlockHeaders[i]
		}
		s = append(s, "MiniBlockHeaders: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "ReceiptsHash: "+fmt.Sprintf("%#v", this.ReceiptsHash)+",\n")
	s = append(s, "EpochStart: "+strings.Replace(this.EpochStart.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "ChainID: "+fmt.Sprintf("%#v", this.ChainID)+",\n")
	s = append(s, "SoftwareVersion: "+fmt.Sprintf("%#v", this.SoftwareVersion)+",\n")
	s = append(s, "AccumulatedFees: "+fmt.Sprintf("%#v", this.AccumulatedFees)+",\n")
	s = append(s, "AccumulatedFeesInEpoch: "+fmt.Sprintf("%#v", this.AccumulatedFeesInEpoch)+",\n")
	s = append(s, "DeveloperFees: "+fmt.Sprintf("%#v", this.DeveloperFees)+",\n")
	s = append(s, "DevFeesInEpoch: "+fmt.Sprintf("%#v", this.DevFeesInEpoch)+",\n")
	s = append(s, "TxCount: "+fmt.Sprintf("%#v", this.TxCount)+",\n")
	s = append(s, "Reserved: "+fmt.Sprintf("%#v", this.Reserved)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringMetaBlock(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *PeerData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PeerData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PeerData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.ValueChange)
		i -= size
		if _, err := __caster.MarshalTo(m.ValueChange, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.TimeStamp != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.TimeStamp))
		i--
		dAtA[i] = 0x20
	}
	if m.Action != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.Action))
		i--
		dAtA[i] = 0x18
	}
	if len(m.PublicKey) > 0 {
		i -= len(m.PublicKey)
		copy(dAtA[i:], m.PublicKey)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.PublicKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ShardData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ShardData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ShardData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.DeveloperFees)
		i -= size
		if _, err := __caster.MarshalTo(m.DeveloperFees, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x72
	if m.LastIncludedMetaNonce != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.LastIncludedMetaNonce))
		i--
		dAtA[i] = 0x68
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.AccumulatedFees)
		i -= size
		if _, err := __caster.MarshalTo(m.AccumulatedFees, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	if m.NumPendingMiniBlocks != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.NumPendingMiniBlocks))
		i--
		dAtA[i] = 0x58
	}
	if m.Nonce != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x50
	}
	if len(m.PrevHash) > 0 {
		i -= len(m.PrevHash)
		copy(dAtA[i:], m.PrevHash)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.PrevHash)))
		i--
		dAtA[i] = 0x4a
	}
	if m.Round != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.Round))
		i--
		dAtA[i] = 0x40
	}
	if m.TxCount != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.TxCount))
		i--
		dAtA[i] = 0x38
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.PubKeysBitmap) > 0 {
		i -= len(m.PubKeysBitmap)
		copy(dAtA[i:], m.PubKeysBitmap)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.PubKeysBitmap)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.PrevRandSeed) > 0 {
		i -= len(m.PrevRandSeed)
		copy(dAtA[i:], m.PrevRandSeed)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.PrevRandSeed)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ShardMiniBlockHeaders) > 0 {
		for iNdEx := len(m.ShardMiniBlockHeaders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ShardMiniBlockHeaders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetaBlock(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.HeaderHash) > 0 {
		i -= len(m.HeaderHash)
		copy(dAtA[i:], m.HeaderHash)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.HeaderHash)))
		i--
		dAtA[i] = 0x12
	}
	if m.ShardID != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.ShardID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EpochStartShardData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EpochStartShardData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EpochStartShardData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ScheduledRootHash) > 0 {
		i -= len(m.ScheduledRootHash)
		copy(dAtA[i:], m.ScheduledRootHash)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.ScheduledRootHash)))
		i--
		dAtA[i] = 0x52
	}
	if m.Epoch != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.Epoch))
		i--
		dAtA[i] = 0x48
	}
	if m.Nonce != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x40
	}
	if m.Round != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.Round))
		i--
		dAtA[i] = 0x38
	}
	if len(m.PendingMiniBlockHeaders) > 0 {
		for iNdEx := len(m.PendingMiniBlockHeaders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PendingMiniBlockHeaders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetaBlock(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.LastFinishedMetaBlock) > 0 {
		i -= len(m.LastFinishedMetaBlock)
		copy(dAtA[i:], m.LastFinishedMetaBlock)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.LastFinishedMetaBlock)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.FirstPendingMetaBlock) > 0 {
		i -= len(m.FirstPendingMetaBlock)
		copy(dAtA[i:], m.FirstPendingMetaBlock)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.FirstPendingMetaBlock)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RootHash) > 0 {
		i -= len(m.RootHash)
		copy(dAtA[i:], m.RootHash)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.RootHash)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.HeaderHash) > 0 {
		i -= len(m.HeaderHash)
		copy(dAtA[i:], m.HeaderHash)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.HeaderHash)))
		i--
		dAtA[i] = 0x12
	}
	if m.ShardID != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.ShardID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Economics) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Economics) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Economics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PrevEpochStartHash) > 0 {
		i -= len(m.PrevEpochStartHash)
		copy(dAtA[i:], m.PrevEpochStartHash)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.PrevEpochStartHash)))
		i--
		dAtA[i] = 0x42
	}
	if m.PrevEpochStartRound != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.PrevEpochStartRound))
		i--
		dAtA[i] = 0x38
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.NodePrice)
		i -= size
		if _, err := __caster.MarshalTo(m.NodePrice, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.RewardsForProtocolSustainability)
		i -= size
		if _, err := __caster.MarshalTo(m.RewardsForProtocolSustainability, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.RewardsPerBlock)
		i -= size
		if _, err := __caster.MarshalTo(m.RewardsPerBlock, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.TotalNewlyMinted)
		i -= size
		if _, err := __caster.MarshalTo(m.TotalNewlyMinted, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.TotalToDistribute)
		i -= size
		if _, err := __caster.MarshalTo(m.TotalToDistribute, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.TotalSupply)
		i -= size
		if _, err := __caster.MarshalTo(m.TotalSupply, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *EpochStart) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EpochStart) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EpochStart) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Economics.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.LastFinalizedHeaders) > 0 {
		for iNdEx := len(m.LastFinalizedHeaders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LastFinalizedHeaders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetaBlock(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *MetaBlock) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MetaBlock) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetaBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reserved) > 0 {
		i -= len(m.Reserved)
		copy(dAtA[i:], m.Reserved)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.Reserved)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd2
	}
	if m.TxCount != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.TxCount))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc8
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.DevFeesInEpoch)
		i -= size
		if _, err := __caster.MarshalTo(m.DevFeesInEpoch, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xc2
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.DeveloperFees)
		i -= size
		if _, err := __caster.MarshalTo(m.DeveloperFees, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xba
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.AccumulatedFeesInEpoch)
		i -= size
		if _, err := __caster.MarshalTo(m.AccumulatedFeesInEpoch, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xb2
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		size := __caster.Size(m.AccumulatedFees)
		i -= size
		if _, err := __caster.MarshalTo(m.AccumulatedFees, dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xaa
	if len(m.SoftwareVersion) > 0 {
		i -= len(m.SoftwareVersion)
		copy(dAtA[i:], m.SoftwareVersion)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.SoftwareVersion)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if len(m.ChainID) > 0 {
		i -= len(m.ChainID)
		copy(dAtA[i:], m.ChainID)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.ChainID)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	{
		size, err := m.EpochStart.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMetaBlock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	if len(m.ReceiptsHash) > 0 {
		i -= len(m.ReceiptsHash)
		copy(dAtA[i:], m.ReceiptsHash)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.ReceiptsHash)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if len(m.MiniBlockHeaders) > 0 {
		for iNdEx := len(m.MiniBlockHeaders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MiniBlockHeaders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetaBlock(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.ValidatorStatsRootHash) > 0 {
		i -= len(m.ValidatorStatsRootHash)
		copy(dAtA[i:], m.ValidatorStatsRootHash)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.ValidatorStatsRootHash)))
		i--
		dAtA[i] = 0x72
	}
	if len(m.RootHash) > 0 {
		i -= len(m.RootHash)
		copy(dAtA[i:], m.RootHash)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.RootHash)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.RandSeed) > 0 {
		i -= len(m.RandSeed)
		copy(dAtA[i:], m.RandSeed)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.RandSeed)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.PrevRandSeed) > 0 {
		i -= len(m.PrevRandSeed)
		copy(dAtA[i:], m.PrevRandSeed)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.PrevRandSeed)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.PrevHash) > 0 {
		i -= len(m.PrevHash)
		copy(dAtA[i:], m.PrevHash)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.PrevHash)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.PubKeysBitmap) > 0 {
		i -= len(m.PubKeysBitmap)
		copy(dAtA[i:], m.PubKeysBitmap)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.PubKeysBitmap)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.LeaderSignature) > 0 {
		i -= len(m.LeaderSignature)
		copy(dAtA[i:], m.LeaderSignature)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.LeaderSignature)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintMetaBlock(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.PeerInfo) > 0 {
		for iNdEx := len(m.PeerInfo) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PeerInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetaBlock(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.ShardInfo) > 0 {
		for iNdEx := len(m.ShardInfo) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ShardInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetaBlock(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.TimeStamp != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.TimeStamp))
		i--
		dAtA[i] = 0x20
	}
	if m.Round != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.Round))
		i--
		dAtA[i] = 0x18
	}
	if m.Epoch != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.Epoch))
		i--
		dAtA[i] = 0x10
	}
	if m.Nonce != 0 {
		i = encodeVarintMetaBlock(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintMetaBlock(dAtA []byte, offset int, v uint64) int {
	offset -= sovMetaBlock(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *PeerData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	if m.Action != 0 {
		n += 1 + sovMetaBlock(uint64(m.Action))
	}
	if m.TimeStamp != 0 {
		n += 1 + sovMetaBlock(uint64(m.TimeStamp))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.ValueChange)
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	return n
}

func (m *ShardData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ShardID != 0 {
		n += 1 + sovMetaBlock(uint64(m.ShardID))
	}
	l = len(m.HeaderHash)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	if len(m.ShardMiniBlockHeaders) > 0 {
		for _, e := range m.ShardMiniBlockHeaders {
			l = e.Size()
			n += 1 + l + sovMetaBlock(uint64(l))
		}
	}
	l = len(m.PrevRandSeed)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.PubKeysBitmap)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	if m.TxCount != 0 {
		n += 1 + sovMetaBlock(uint64(m.TxCount))
	}
	if m.Round != 0 {
		n += 1 + sovMetaBlock(uint64(m.Round))
	}
	l = len(m.PrevHash)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	if m.Nonce != 0 {
		n += 1 + sovMetaBlock(uint64(m.Nonce))
	}
	if m.NumPendingMiniBlocks != 0 {
		n += 1 + sovMetaBlock(uint64(m.NumPendingMiniBlocks))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.AccumulatedFees)
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	if m.LastIncludedMetaNonce != 0 {
		n += 1 + sovMetaBlock(uint64(m.LastIncludedMetaNonce))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.DeveloperFees)
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	return n
}

func (m *EpochStartShardData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ShardID != 0 {
		n += 1 + sovMetaBlock(uint64(m.ShardID))
	}
	l = len(m.HeaderHash)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.RootHash)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.FirstPendingMetaBlock)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.LastFinishedMetaBlock)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	if len(m.PendingMiniBlockHeaders) > 0 {
		for _, e := range m.PendingMiniBlockHeaders {
			l = e.Size()
			n += 1 + l + sovMetaBlock(uint64(l))
		}
	}
	if m.Round != 0 {
		n += 1 + sovMetaBlock(uint64(m.Round))
	}
	if m.Nonce != 0 {
		n += 1 + sovMetaBlock(uint64(m.Nonce))
	}
	if m.Epoch != 0 {
		n += 1 + sovMetaBlock(uint64(m.Epoch))
	}
	l = len(m.ScheduledRootHash)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	return n
}

func (m *Economics) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.TotalSupply)
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.TotalToDistribute)
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.TotalNewlyMinted)
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.RewardsPerBlock)
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.RewardsForProtocolSustainability)
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.NodePrice)
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	if m.PrevEpochStartRound != 0 {
		n += 1 + sovMetaBlock(uint64(m.PrevEpochStartRound))
	}
	l = len(m.PrevEpochStartHash)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	return n
}

func (m *EpochStart) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.LastFinalizedHeaders) > 0 {
		for _, e := range m.LastFinalizedHeaders {
			l = e.Size()
			n += 1 + l + sovMetaBlock(uint64(l))
		}
	}
	l = m.Economics.Size()
	n += 1 + l + sovMetaBlock(uint64(l))
	return n
}

func (m *MetaBlock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Nonce != 0 {
		n += 1 + sovMetaBlock(uint64(m.Nonce))
	}
	if m.Epoch != 0 {
		n += 1 + sovMetaBlock(uint64(m.Epoch))
	}
	if m.Round != 0 {
		n += 1 + sovMetaBlock(uint64(m.Round))
	}
	if m.TimeStamp != 0 {
		n += 1 + sovMetaBlock(uint64(m.TimeStamp))
	}
	if len(m.ShardInfo) > 0 {
		for _, e := range m.ShardInfo {
			l = e.Size()
			n += 1 + l + sovMetaBlock(uint64(l))
		}
	}
	if len(m.PeerInfo) > 0 {
		for _, e := range m.PeerInfo {
			l = e.Size()
			n += 1 + l + sovMetaBlock(uint64(l))
		}
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.LeaderSignature)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.PubKeysBitmap)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.PrevHash)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.PrevRandSeed)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.RandSeed)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.RootHash)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.ValidatorStatsRootHash)
	if l > 0 {
		n += 1 + l + sovMetaBlock(uint64(l))
	}
	if len(m.MiniBlockHeaders) > 0 {
		for _, e := range m.MiniBlockHeaders {
			l = e.Size()
			n += 2 + l + sovMetaBlock(uint64(l))
		}
	}
	l = len(m.ReceiptsHash)
	if l > 0 {
		n += 2 + l + sovMetaBlock(uint64(l))
	}
	l = m.EpochStart.Size()
	n += 2 + l + sovMetaBlock(uint64(l))
	l = len(m.ChainID)
	if l > 0 {
		n += 2 + l + sovMetaBlock(uint64(l))
	}
	l = len(m.SoftwareVersion)
	if l > 0 {
		n += 2 + l + sovMetaBlock(uint64(l))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.AccumulatedFees)
		n += 2 + l + sovMetaBlock(uint64(l))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.AccumulatedFeesInEpoch)
		n += 2 + l + sovMetaBlock(uint64(l))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.DeveloperFees)
		n += 2 + l + sovMetaBlock(uint64(l))
	}
	{
		__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
		l = __caster.Size(m.DevFeesInEpoch)
		n += 2 + l + sovMetaBlock(uint64(l))
	}
	if m.TxCount != 0 {
		n += 2 + sovMetaBlock(uint64(m.TxCount))
	}
	l = len(m.Reserved)
	if l > 0 {
		n += 2 + l + sovMetaBlock(uint64(l))
	}
	return n
}

func sovMetaBlock(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMetaBlock(x uint64) (n int) {
	return sovMetaBlock(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *PeerData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PeerData{`,
		`Address:` + fmt.Sprintf("%v", this.Address) + `,`,
		`PublicKey:` + fmt.Sprintf("%v", this.PublicKey) + `,`,
		`Action:` + fmt.Sprintf("%v", this.Action) + `,`,
		`TimeStamp:` + fmt.Sprintf("%v", this.TimeStamp) + `,`,
		`ValueChange:` + fmt.Sprintf("%v", this.ValueChange) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShardData) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForShardMiniBlockHeaders := "[]MiniBlockHeader{"
	for _, f := range this.ShardMiniBlockHeaders {
		repeatedStringForShardMiniBlockHeaders += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForShardMiniBlockHeaders += "}"
	s := strings.Join([]string{`&ShardData{`,
		`ShardID:` + fmt.Sprintf("%v", this.ShardID) + `,`,
		`HeaderHash:` + fmt.Sprintf("%v", this.HeaderHash) + `,`,
		`ShardMiniBlockHeaders:` + repeatedStringForShardMiniBlockHeaders + `,`,
		`PrevRandSeed:` + fmt.Sprintf("%v", this.PrevRandSeed) + `,`,
		`PubKeysBitmap:` + fmt.Sprintf("%v", this.PubKeysBitmap) + `,`,
		`Signature:` + fmt.Sprintf("%v", this.Signature) + `,`,
		`TxCount:` + fmt.Sprintf("%v", this.TxCount) + `,`,
		`Round:` + fmt.Sprintf("%v", this.Round) + `,`,
		`PrevHash:` + fmt.Sprintf("%v", this.PrevHash) + `,`,
		`Nonce:` + fmt.Sprintf("%v", this.Nonce) + `,`,
		`NumPendingMiniBlocks:` + fmt.Sprintf("%v", this.NumPendingMiniBlocks) + `,`,
		`AccumulatedFees:` + fmt.Sprintf("%v", this.AccumulatedFees) + `,`,
		`LastIncludedMetaNonce:` + fmt.Sprintf("%v", this.LastIncludedMetaNonce) + `,`,
		`DeveloperFees:` + fmt.Sprintf("%v", this.DeveloperFees) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EpochStartShardData) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForPendingMiniBlockHeaders := "[]MiniBlockHeader{"
	for _, f := range this.PendingMiniBlockHeaders {
		repeatedStringForPendingMiniBlockHeaders += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForPendingMiniBlockHeaders += "}"
	s := strings.Join([]string{`&EpochStartShardData{`,
		`ShardID:` + fmt.Sprintf("%v", this.ShardID) + `,`,
		`HeaderHash:` + fmt.Sprintf("%v", this.HeaderHash) + `,`,
		`RootHash:` + fmt.Sprintf("%v", this.RootHash) + `,`,
		`FirstPendingMetaBlock:` + fmt.Sprintf("%v", this.FirstPendingMetaBlock) + `,`,
		`LastFinishedMetaBlock:` + fmt.Sprintf("%v", this.LastFinishedMetaBlock) + `,`,
		`PendingMiniBlockHeaders:` + repeatedStringForPendingMiniBlockHeaders + `,`,
		`Round:` + fmt.Sprintf("%v", this.Round) + `,`,
		`Nonce:` + fmt.Sprintf("%v", this.Nonce) + `,`,
		`Epoch:` + fmt.Sprintf("%v", this.Epoch) + `,`,
		`ScheduledRootHash:` + fmt.Sprintf("%v", this.ScheduledRootHash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Economics) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Economics{`,
		`TotalSupply:` + fmt.Sprintf("%v", this.TotalSupply) + `,`,
		`TotalToDistribute:` + fmt.Sprintf("%v", this.TotalToDistribute) + `,`,
		`TotalNewlyMinted:` + fmt.Sprintf("%v", this.TotalNewlyMinted) + `,`,
		`RewardsPerBlock:` + fmt.Sprintf("%v", this.RewardsPerBlock) + `,`,
		`RewardsForProtocolSustainability:` + fmt.Sprintf("%v", this.RewardsForProtocolSustainability) + `,`,
		`NodePrice:` + fmt.Sprintf("%v", this.NodePrice) + `,`,
		`PrevEpochStartRound:` + fmt.Sprintf("%v", this.PrevEpochStartRound) + `,`,
		`PrevEpochStartHash:` + fmt.Sprintf("%v", this.PrevEpochStartHash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EpochStart) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForLastFinalizedHeaders := "[]EpochStartShardData{"
	for _, f := range this.LastFinalizedHeaders {
		repeatedStringForLastFinalizedHeaders += strings.Replace(strings.Replace(f.String(), "EpochStartShardData", "EpochStartShardData", 1), `&`, ``, 1) + ","
	}
	repeatedStringForLastFinalizedHeaders += "}"
	s := strings.Join([]string{`&EpochStart{`,
		`LastFinalizedHeaders:` + repeatedStringForLastFinalizedHeaders + `,`,
		`Economics:` + strings.Replace(strings.Replace(this.Economics.String(), "Economics", "Economics", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetaBlock) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForShardInfo := "[]ShardData{"
	for _, f := range this.ShardInfo {
		repeatedStringForShardInfo += strings.Replace(strings.Replace(f.String(), "ShardData", "ShardData", 1), `&`, ``, 1) + ","
	}
	repeatedStringForShardInfo += "}"
	repeatedStringForPeerInfo := "[]PeerData{"
	for _, f := range this.PeerInfo {
		repeatedStringForPeerInfo += strings.Replace(strings.Replace(f.String(), "PeerData", "PeerData", 1), `&`, ``, 1) + ","
	}
	repeatedStringForPeerInfo += "}"
	repeatedStringForMiniBlockHeaders := "[]MiniBlockHeader{"
	for _, f := range this.MiniBlockHeaders {
		repeatedStringForMiniBlockHeaders += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForMiniBlockHeaders += "}"
	s := strings.Join([]string{`&MetaBlock{`,
		`Nonce:` + fmt.Sprintf("%v", this.Nonce) + `,`,
		`Epoch:` + fmt.Sprintf("%v", this.Epoch) + `,`,
		`Round:` + fmt.Sprintf("%v", this.Round) + `,`,
		`TimeStamp:` + fmt.Sprintf("%v", this.TimeStamp) + `,`,
		`ShardInfo:` + repeatedStringForShardInfo + `,`,
		`PeerInfo:` + repeatedStringForPeerInfo + `,`,
		`Signature:` + fmt.Sprintf("%v", this.Signature) + `,`,
		`LeaderSignature:` + fmt.Sprintf("%v", this.LeaderSignature) + `,`,
		`PubKeysBitmap:` + fmt.Sprintf("%v", this.PubKeysBitmap) + `,`,
		`PrevHash:` + fmt.Sprintf("%v", this.PrevHash) + `,`,
		`PrevRandSeed:` + fmt.Sprintf("%v", this.PrevRandSeed) + `,`,
		`RandSeed:` + fmt.Sprintf("%v", this.RandSeed) + `,`,
		`RootHash:` + fmt.Sprintf("%v", this.RootHash) + `,`,
		`ValidatorStatsRootHash:` + fmt.Sprintf("%v", this.ValidatorStatsRootHash) + `,`,
		`MiniBlockHeaders:` + repeatedStringForMiniBlockHeaders + `,`,
		`ReceiptsHash:` + fmt.Sprintf("%v", this.ReceiptsHash) + `,`,
		`EpochStart:` + strings.Replace(strings.Replace(this.EpochStart.String(), "EpochStart", "EpochStart", 1), `&`, ``, 1) + `,`,
		`ChainID:` + fmt.Sprintf("%v", this.ChainID) + `,`,
		`SoftwareVersion:` + fmt.Sprintf("%v", this.SoftwareVersion) + `,`,
		`AccumulatedFees:` + fmt.Sprintf("%v", this.AccumulatedFees) + `,`,
		`AccumulatedFeesInEpoch:` + fmt.Sprintf("%v", this.AccumulatedFeesInEpoch) + `,`,
		`DeveloperFees:` + fmt.Sprintf("%v", this.DeveloperFees) + `,`,
		`DevFeesInEpoch:` + fmt.Sprintf("%v", this.DevFeesInEpoch) + `,`,
		`TxCount:` + fmt.Sprintf("%v", this.TxCount) + `,`,
		`Reserved:` + fmt.Sprintf("%v", this.Reserved) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringMetaBlock(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *PeerData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetaBlock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PeerData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PeerData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
			if m.Address == nil {
				m.Address = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PublicKey == nil {
				m.PublicKey = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			m.Action = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Action |= PeerAction(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeStamp", wireType)
			}
			m.TimeStamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeStamp |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueChange", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.ValueChange = tmp
				}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetaBlock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShardData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetaBlock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ShardData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShardData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardID", wireType)
			}
			m.ShardID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ShardID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeaderHash = append(m.HeaderHash[:0], dAtA[iNdEx:postIndex]...)
			if m.HeaderHash == nil {
				m.HeaderHash = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardMiniBlockHeaders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ShardMiniBlockHeaders = append(m.ShardMiniBlockHeaders, MiniBlockHeader{})
			if err := m.ShardMiniBlockHeaders[len(m.ShardMiniBlockHeaders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevRandSeed", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PrevRandSeed = append(m.PrevRandSeed[:0], dAtA[iNdEx:postIndex]...)
			if m.PrevRandSeed == nil {
				m.PrevRandSeed = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PubKeysBitmap", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PubKeysBitmap = append(m.PubKeysBitmap[:0], dAtA[iNdEx:postIndex]...)
			if m.PubKeysBitmap == nil {
				m.PubKeysBitmap = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxCount", wireType)
			}
			m.TxCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TxCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType)
			}
			m.Round = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Round |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PrevHash = append(m.PrevHash[:0], dAtA[iNdEx:postIndex]...)
			if m.PrevHash == nil {
				m.PrevHash = []byte{}
			}
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumPendingMiniBlocks", wireType)
			}
			m.NumPendingMiniBlocks = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumPendingMiniBlocks |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccumulatedFees", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.AccumulatedFees = tmp
				}
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastIncludedMetaNonce", wireType)
			}
			m.LastIncludedMetaNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastIncludedMetaNonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeveloperFees", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.DeveloperFees = tmp
				}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetaBlock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EpochStartShardData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetaBlock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EpochStartShardData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EpochStartShardData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardID", wireType)
			}
			m.ShardID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ShardID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeaderHash = append(m.HeaderHash[:0], dAtA[iNdEx:postIndex]...)
			if m.HeaderHash == nil {
				m.HeaderHash = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootHash = append(m.RootHash[:0], dAtA[iNdEx:postIndex]...)
			if m.RootHash == nil {
				m.RootHash = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstPendingMetaBlock", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FirstPendingMetaBlock = append(m.FirstPendingMetaBlock[:0], dAtA[iNdEx:postIndex]...)
			if m.FirstPendingMetaBlock == nil {
				m.FirstPendingMetaBlock = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastFinishedMetaBlock", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LastFinishedMetaBlock = append(m.LastFinishedMetaBlock[:0], dAtA[iNdEx:postIndex]...)
			if m.LastFinishedMetaBlock == nil {
				m.LastFinishedMetaBlock = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PendingMiniBlockHeaders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PendingMiniBlockHeaders = append(m.PendingMiniBlockHeaders, MiniBlockHeader{})
			if err := m.PendingMiniBlockHeaders[len(m.PendingMiniBlockHeaders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType)
			}
			m.Round = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Round |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			m.Epoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScheduledRootHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScheduledRootHash = append(m.ScheduledRootHash[:0], dAtA[iNdEx:postIndex]...)
			if m.ScheduledRootHash == nil {
				m.ScheduledRootHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetaBlock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Economics) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetaBlock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Economics: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Economics: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalSupply", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.TotalSupply = tmp
				}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalToDistribute", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.TotalToDistribute = tmp
				}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalNewlyMinted", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.TotalNewlyMinted = tmp
				}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardsPerBlock", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.RewardsPerBlock = tmp
				}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardsForProtocolSustainability", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.RewardsForProtocolSustainability = tmp
				}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodePrice", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.NodePrice = tmp
				}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevEpochStartRound", wireType)
			}
			m.PrevEpochStartRound = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PrevEpochStartRound |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevEpochStartHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PrevEpochStartHash = append(m.PrevEpochStartHash[:0], dAtA[iNdEx:postIndex]...)
			if m.PrevEpochStartHash == nil {
				m.PrevEpochStartHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetaBlock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EpochStart) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetaBlock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EpochStart: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EpochStart: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastFinalizedHeaders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LastFinalizedHeaders = append(m.LastFinalizedHeaders, EpochStartShardData{})
			if err := m.LastFinalizedHeaders[len(m.LastFinalizedHeaders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Economics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Economics.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetaBlock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetaBlock) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetaBlock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MetaBlock: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetaBlock: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			m.Epoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType)
			}
			m.Round = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Round |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeStamp", wireType)
			}
			m.TimeStamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeStamp |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ShardInfo = append(m.ShardInfo, ShardData{})
			if err := m.ShardInfo[len(m.ShardInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PeerInfo = append(m.PeerInfo, PeerData{})
			if err := m.PeerInfo[len(m.PeerInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LeaderSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LeaderSignature = append(m.LeaderSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.LeaderSignature == nil {
				m.LeaderSignature = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PubKeysBitmap", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PubKeysBitmap = append(m.PubKeysBitmap[:0], dAtA[iNdEx:postIndex]...)
			if m.PubKeysBitmap == nil {
				m.PubKeysBitmap = []byte{}
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PrevHash = append(m.PrevHash[:0], dAtA[iNdEx:postIndex]...)
			if m.PrevHash == nil {
				m.PrevHash = []byte{}
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevRandSeed", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PrevRandSeed = append(m.PrevRandSeed[:0], dAtA[iNdEx:postIndex]...)
			if m.PrevRandSeed == nil {
				m.PrevRandSeed = []byte{}
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RandSeed", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RandSeed = append(m.RandSeed[:0], dAtA[iNdEx:postIndex]...)
			if m.RandSeed == nil {
				m.RandSeed = []byte{}
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootHash = append(m.RootHash[:0], dAtA[iNdEx:postIndex]...)
			if m.RootHash == nil {
				m.RootHash = []byte{}
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorStatsRootHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorStatsRootHash = append(m.ValidatorStatsRootHash[:0], dAtA[iNdEx:postIndex]...)
			if m.ValidatorStatsRootHash == nil {
				m.ValidatorStatsRootHash = []byte{}
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MiniBlockHeaders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MiniBlockHeaders = append(m.MiniBlockHeaders, MiniBlockHeader{})
			if err := m.MiniBlockHeaders[len(m.MiniBlockHeaders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReceiptsHash = append(m.ReceiptsHash[:0], dAtA[iNdEx:postIndex]...)
			if m.ReceiptsHash == nil {
				m.ReceiptsHash = []byte{}
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochStart", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.EpochStart.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainID = append(m.ChainID[:0], dAtA[iNdEx:postIndex]...)
			if m.ChainID == nil {
				m.ChainID = []byte{}
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SoftwareVersion", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SoftwareVersion = append(m.SoftwareVersion[:0], dAtA[iNdEx:postIndex]...)
			if m.SoftwareVersion == nil {
				m.SoftwareVersion = []byte{}
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccumulatedFees", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.AccumulatedFees = tmp
				}
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccumulatedFeesInEpoch", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.AccumulatedFeesInEpoch = tmp
				}
			}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeveloperFees", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.DeveloperFees = tmp
				}
			}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevFeesInEpoch", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			{
				__caster := &github_com_ThotaGopichandThota_gn_core2_data.BigIntCaster{}
				if tmp, err := __caster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				} else {
					m.DevFeesInEpoch = tmp
				}
			}
			iNdEx = postIndex
		case 25:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxCount", wireType)
			}
			m.TxCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TxCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reserved", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetaBlock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reserved = append(m.Reserved[:0], dAtA[iNdEx:postIndex]...)
			if m.Reserved == nil {
				m.Reserved = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetaBlock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetaBlock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMetaBlock(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowMetaBlock
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMetaBlock
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthMetaBlock
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMetaBlock
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMetaBlock
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMetaBlock        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMetaBlock          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMetaBlock = fmt.Errorf("proto: unexpected end of group")
)