modified the allocations in p2p

fixed encode and decode of blockview and headerview

bugfix that needs to go with f52ce02 enconde/decode of headeview blockview

Makefile

@@ -30,7 +30,7 @@ mocks:
 ## generate protobuf files
 protogen:
 	@echo "Generating protobuf files"
-	@find . -name '*.proto' -exec protoc --go_out=. --go_opt=paths=source_relative {} \;
+	@find . -name '*.proto' -exec protoc --go_out=. --go_opt=paths=source_relative --experimental_allow_proto3_optional {} \;
 
 debug:
 	go build -gcflags=all="-N -l" -v -o build/bin/go-quai ./cmd/go-quai

core/types/proto_block.proto

@@ -105,13 +105,11 @@ message ProtoWorkObject {
 message ProtoWorkObjects { repeated ProtoWorkObject work_objects = 1; }
 
 message ProtoWorkObjectBlockView {
-    optional ProtoWorkObjectHeader wo_header = 1;
-    optional ProtoWorkObjectBody wo_body = 2;
+    optional ProtoWorkObject work_object = 1;
 }
 
 message ProtoWorkObjectHeaderView {
-    optional ProtoWorkObjectHeader wo_header = 1;
-    optional ProtoWorkObjectBody wo_body = 2;
+    optional ProtoWorkObject work_object = 1;
 }
 
 message ProtoAccessTuple {

core/types/wo.go

@@ -767,60 +767,42 @@ func (wo *WorkObject) ProtoEncode(woType WorkObjectView) (*ProtoWorkObject, erro
 }
 
 func (wo *WorkObjectHeaderView) ProtoEncode() (*ProtoWorkObjectHeaderView, error) {
-	header, err := wo.woHeader.ProtoEncode()
-	if err != nil {
-		return nil, err
-	}
-	body, err := wo.woBody.ProtoEncode()
+	protoWo, err := wo.WorkObject.ProtoEncode(HeaderObject)
 	if err != nil {
 		return nil, err
 	}
 	return &ProtoWorkObjectHeaderView{
-		WoHeader: header,
-		WoBody:   body,
+		WorkObject: protoWo,
 	}, nil
 }
 
 func (wo *WorkObjectBlockView) ProtoEncode() (*ProtoWorkObjectBlockView, error) {
-	header, err := wo.woHeader.ProtoEncode()
-	if err != nil {
-		return nil, err
-	}
-	body, err := wo.woBody.ProtoEncode()
+	protoWo, err := wo.WorkObject.ProtoEncode(BlockObject)
 	if err != nil {
 		return nil, err
 	}
 	return &ProtoWorkObjectBlockView{
-		WoHeader: header,
-		WoBody:   body,
+		WorkObject: protoWo,
 	}, nil
 }
 
 func (wo *WorkObjectHeaderView) ProtoDecode(data *ProtoWorkObjectHeaderView, location common.Location) error {
-	wo.woHeader = new(WorkObjectHeader)
-	err := wo.woHeader.ProtoDecode(data.GetWoHeader())
-	if err != nil {
-		return err
-	}
-	wo.woBody = new(WorkObjectBody)
-	err = wo.woBody.ProtoDecode(data.GetWoBody(), location, BlockObject)
+	decodeWo := new(WorkObject)
+	err := decodeWo.ProtoDecode(data.GetWorkObject(), location, HeaderObject)
 	if err != nil {
 		return err
 	}
+	wo.WorkObject = decodeWo
 	return nil
 }
 
 func (wob *WorkObjectBlockView) ProtoDecode(data *ProtoWorkObjectBlockView, location common.Location) error {
-	wob.woHeader = new(WorkObjectHeader)
-	err := wob.woHeader.ProtoDecode(data.GetWoHeader())
-	if err != nil {
-		return err
-	}
-	wob.woBody = new(WorkObjectBody)
-	err = wob.woBody.ProtoDecode(data.GetWoBody(), location, BlockObject)
+	decodeWo := new(WorkObject)
+	err := decodeWo.ProtoDecode(data.GetWorkObject(), location, BlockObject)
 	if err != nil {
 		return err
 	}
+	wob.WorkObject = decodeWo
 	return nil
 }
 

p2p/node/api.go

@@ -331,10 +331,8 @@ func (p *P2PNode) GetTrieNode(hash common.Hash, location common.Location) *trie.
 }
 
 func (p *P2PNode) handleBroadcast(sourcePeer peer.ID, topic string, data interface{}, nodeLocation common.Location) {
-	switch v := data.(type) {
-	case types.WorkObject:
-		p.cacheAdd(v.Hash(), &v, nodeLocation)
-	// TODO: send it to consensus
+	switch data.(type) {
+	case types.WorkObjectBlockView:
 	case types.WorkObjectHeaderView:
 	case types.Transactions:
 	case types.WorkObjectHeader:

p2p/pb/proto_services.go

@@ -270,79 +270,72 @@ func ConvertAndMarshal(data interface{}) ([]byte, error) {
 func UnmarshalAndConvert(data []byte, sourceLocation common.Location, dataPtr *interface{}, datatype interface{}) error {
 	switch datatype.(type) {
 	case *types.WorkObjectBlockView:
-		protoWorkObject := &types.ProtoWorkObject{}
+		protoWorkObject := &types.ProtoWorkObjectBlockView{}
 		err := proto.Unmarshal(data, protoWorkObject)
 		if err != nil {
 			return err
 		}
-		workObject := &types.WorkObject{}
-		if protoWorkObject.WoHeader == nil {
-			return errors.New("woheader is nil")
-		}
-		if protoWorkObject.WoHeader.Location == nil {
-			return errors.New("location is nil")
-		}
-		err = workObject.ProtoDecode(protoWorkObject, sourceLocation, types.BlockObject)
+
+		workObjectBlockView := types.WorkObjectBlockView{}
+		workObjectBlockView.WorkObject = &types.WorkObject{}
+		err = workObjectBlockView.ProtoDecode(protoWorkObject, sourceLocation)
 		if err != nil {
 			return err
 		}
-		*dataPtr = *workObject
+		*dataPtr = workObjectBlockView
 		return nil
 	case *types.WorkObjectHeaderView:
 		protoWorkObject := &types.ProtoWorkObjectHeaderView{}
 		err := proto.Unmarshal(data, protoWorkObject)
 		if err != nil {
 			return err
 		}
-		workObjectHeaderView := &types.WorkObjectHeaderView{}
-		if protoWorkObject.WoHeader.Location == nil {
-			return errors.New("location is nil")
-		}
+		workObjectHeaderView := types.WorkObjectHeaderView{}
 		workObjectHeaderView.WorkObject = &types.WorkObject{}
 		err = workObjectHeaderView.ProtoDecode(protoWorkObject, sourceLocation)
 		if err != nil {
 			return err
 		}
-		*dataPtr = *workObjectHeaderView
+		*dataPtr = workObjectHeaderView
 		return nil
 	case *types.WorkObjectHeader:
 		protoWorkObjectHeader := &types.ProtoWorkObjectHeader{}
 		err := proto.Unmarshal(data, protoWorkObjectHeader)
 		if err != nil {
 			return err
 		}
-		workObjectHeader := &types.WorkObjectHeader{}
+		workObjectHeader := types.WorkObjectHeader{}
 		err = workObjectHeader.ProtoDecode(protoWorkObjectHeader)
 		if err != nil {
 			return err
 		}
-		*dataPtr = *workObjectHeader
+		*dataPtr = workObjectHeader
 		return nil
 	case *types.Header:
 		protoHeader := &types.ProtoHeader{}
 		err := proto.Unmarshal(data, protoHeader)
 		if err != nil {
 			return err
 		}
-		header := &types.Header{}
+		header := types.Header{}
 		err = header.ProtoDecode(protoHeader, sourceLocation)
 		if err != nil {
 			return err
 		}
-		*dataPtr = *header
+		*dataPtr = header
 		return nil
 	case *types.Transactions:
 		protoTransactions := &types.ProtoTransactions{}
 		err := proto.Unmarshal(data, protoTransactions)
 		if err != nil {
 			return err
 		}
-		transactions := &types.Transactions{}
+		transactions := types.Transactions{}
 		err = transactions.ProtoDecode(protoTransactions, sourceLocation)
 		if err != nil {
 			return err
 		}
-		*dataPtr = *transactions
+		*dataPtr = transactions
 		return nil
 	case common.Hash:
 		protoHash := &common.ProtoHash{}

quai/p2p_backend.go

@@ -80,7 +80,7 @@ func (qbe *QuaiBackend) GetBackend(location common.Location) *quaiapi.Backend {
 func (qbe *QuaiBackend) OnNewBroadcast(sourcePeer p2p.PeerID, topic string, data interface{}, nodeLocation common.Location) bool {
 	defer types.ObjectPool.Put(data)
 	switch data := data.(type) {
-	case types.WorkObject:
+	case types.WorkObjectBlockView:
 		backend := *qbe.GetBackend(nodeLocation)
 		if backend == nil {
 			log.Global.Error("no backend found")
@@ -89,7 +89,7 @@ func (qbe *QuaiBackend) OnNewBroadcast(sourcePeer p2p.PeerID, topic string, data
 		// TODO: Verify the Block before writing it
 		// TODO: Determine if the block information was lively or stale and rate
 		// the peer accordingly
-		backend.WriteBlock(&data)
+		backend.WriteBlock(data.WorkObject)
 		// If it was a good broadcast, mark the peer as lively
 		qbe.p2pBackend.MarkLivelyPeer(sourcePeer, topic)
 	case types.WorkObjectHeaderView:
@@ -100,7 +100,7 @@ func (qbe *QuaiBackend) OnNewBroadcast(sourcePeer p2p.PeerID, topic string, data
 		}
 		// Only append this in the case of the slice
 		if !backend.ProcessingState() && backend.NodeCtx() == common.ZONE_CTX {
-			backend.WriteBlock(data.ConvertToBlockView().WorkObject)
+			backend.WriteBlock(data.WorkObject)
 		}
 		// If it was a good broadcast, mark the peer as lively
 		qbe.p2pBackend.MarkLivelyPeer(sourcePeer, topic)