Introduce Block and Header views to optimize bandwidth usage across t…

…opics

cmd/utils/hierarchical_coordinator.go

@@ -134,7 +134,8 @@ func (hc *HierarchicalCoordinator) startNode(logPath string, quaiBackend quai.Co
 	quaiBackend.SetApiBackend(&apiBackend, location)
 
 	// Subscribe to the new topics after setting the api backend
-	hc.p2p.Subscribe(location, &types.WorkObject{})
+	hc.p2p.Subscribe(location, &types.WorkObjectBlockView{})
+	hc.p2p.Subscribe(location, &types.WorkObjectHeaderView{})
 	hc.p2p.Subscribe(location, common.Hash{})
 	hc.p2p.Subscribe(location, &types.Transaction{})
 

core/types/wo.go

@@ -989,3 +989,32 @@ func (wb *WorkObjectBody) RPCMarshalWorkObjectBody() map[string]interface{} {
 
 	return result
 }
+
+////////////////////////////////////////////////////////////
+///////////////////// Work Object Views ////////////////////
+////////////////////////////////////////////////////////////
+
+type WorkObjectBlockView struct {
+	*WorkObject
+}
+
+type WorkObjectHeaderView struct {
+	*WorkObject
+}
+
+////////////////////////////////////////////////////////////
+////////////// View Conversion/Getter Methods //////////////
+////////////////////////////////////////////////////////////
+
+func (wo *WorkObject) ConvertToHeaderView() *WorkObjectHeaderView {
+	newWo := NewWorkObjectWithHeader(wo, nil, common.ZONE_CTX, HeaderObject)
+	return &WorkObjectHeaderView{
+		WorkObject: newWo,
+	}
+}
+
+func (wo *WorkObject) ConvertToBlockView() *WorkObjectBlockView {
+	return &WorkObjectBlockView{
+		WorkObject: wo,
+	}
+}

internal/quaiapi/backend.go

@@ -128,7 +128,7 @@ type Backend interface {
 	Logger() *log.Logger
 
 	// P2P apis
-	BroadcastBlock(block *types.WorkObject, location common.Location) error
+	BroadcastWorkObject(*types.WorkObject, common.Location) error
 }
 
 func GetAPIs(apiBackend Backend) []rpc.API {

internal/quaiapi/quai_api.go

@@ -706,7 +706,7 @@ func (s *PublicBlockChainQuaiAPI) ReceiveMinedHeader(ctx context.Context, raw js
 
 	// Broadcast the block and announce chain insertion event
 	if block.Header() != nil {
-		err := s.b.BroadcastBlock(block, s.b.NodeLocation())
+		err := s.b.BroadcastWorkObject(block, s.b.NodeLocation())
 		if err != nil {
 			s.b.Logger().WithField("err", err).Error("Error broadcasting block")
 		}

p2p/pb/proto_services.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/dominant-strategies/go-quai/common"
 	"github.com/dominant-strategies/go-quai/core/types"
-	"github.com/dominant-strategies/go-quai/log"
 	"github.com/dominant-strategies/go-quai/trie"
 )
 
@@ -190,29 +189,28 @@ func DecodeQuaiResponse(respMsg *QuaiResponseMessage) (uint32, interface{}, erro
 // Converts a custom go type to a proto type and marhsals it into a protobuf message
 func ConvertAndMarshal(data interface{}) ([]byte, error) {
 	switch data := data.(type) {
-	case *types.WorkObject:
-		log.Global.Tracef("marshalling block: %+v", data)
-		protoBlock, err := data.ProtoEncode(types.BlockObject)
-		if err != nil {
-			return nil, err
+	case *types.WorkObjectHeaderView, *types.WorkObjectBlockView:
+		var protoBlock *types.ProtoWorkObject
+		var err error
+		switch data := data.(type) {
+		case *types.WorkObjectHeaderView:
+			protoBlock, err = data.ProtoEncode(types.HeaderObject)
+		case *types.WorkObjectBlockView:
+			protoBlock, err = data.ProtoEncode(types.BlockObject)
+		default:
+			return nil, errors.New("unsupported data type")
 		}
-		return proto.Marshal(protoBlock)
-	case *types.Header:
-		log.Global.Tracef("marshalling header: %+v", data)
-		protoHeader, err := data.ProtoEncode()
 		if err != nil {
 			return nil, err
 		}
-		return proto.Marshal(protoHeader)
+		return proto.Marshal(protoBlock)
 	case *types.Transaction:
-		log.Global.Tracef("marshalling transaction: %+v", data)
 		protoTransaction, err := data.ProtoEncode()
 		if err != nil {
 			return nil, err
 		}
 		return proto.Marshal(protoTransaction)
 	case common.Hash:
-		log.Global.Tracef("marshalling hash: %+v", data)
 		protoHash := data.ProtoEncode()
 		return proto.Marshal(protoHash)
 	default:
@@ -223,7 +221,7 @@ func ConvertAndMarshal(data interface{}) ([]byte, error) {
 // Unmarshals a protobuf message into a proto type and converts it to a custom go type
 func UnmarshalAndConvert(data []byte, sourceLocation common.Location, dataPtr *interface{}, datatype interface{}) error {
 	switch datatype.(type) {
-	case *types.WorkObject:
+	case *types.WorkObjectHeaderView, *types.WorkObjectBlockView:
 		protoWorkObject := &types.ProtoWorkObject{}
 		err := proto.Unmarshal(data, protoWorkObject)
 		if err != nil {

p2p/pubsubManager/utils.go

@@ -24,7 +24,9 @@ const (
 func TopicName(genesis common.Hash, location common.Location, data interface{}) (string, error) {
 	baseTopic := strings.Join([]string{genesis.String(), location.Name()}, "/")
 	switch data.(type) {
-	case *types.WorkObject:
+	case *types.WorkObjectHeaderView:
+		return strings.Join([]string{baseTopic, C_headerType}, "/"), nil
+	case *types.WorkObjectBlockView:
 		return strings.Join([]string{baseTopic, C_workObjectType}, "/"), nil
 	case common.Hash:
 		return strings.Join([]string{baseTopic, C_hashType}, "/"), nil

quai/api_backend.go

@@ -574,9 +574,19 @@ func (b *QuaiAPIBackend) SubscribeExpansionEvent(ch chan<- core.ExpansionEvent)
 	return b.quai.core.SubscribeExpansionEvent(ch)
 }
 
-// ///////////////////////////
-// /////// P2P ///////////////
-// ///////////////////////////
-func (b *QuaiAPIBackend) BroadcastBlock(block *types.WorkObject, location common.Location) error {
-	return b.quai.p2p.Broadcast(location, block)
+// ////////////////////////////
+// //////// P2P ///////////////
+// ////////////////////////////
+func (b *QuaiAPIBackend) BroadcastWorkObject(wo *types.WorkObject, location common.Location) error {
+	err := b.quai.p2p.Broadcast(location, wo.ConvertToBlockView())
+	if err != nil {
+		return err
+	}
+
+	err = b.quai.p2p.Broadcast(location, wo.ConvertToHeaderView())
+	if err != nil {
+		return err
+	}
+
+	return nil
 }