Add PruningPointProof to the P2P protocol

app/appmessage/domainconverters.go

@@ -520,3 +520,27 @@ func DomainBlockWithTrustedDataToBlockWithTrustedData(block *externalapi.BlockWi
 		GHOSTDAGData: ghostdagData,
 	}
 }
+
+// MsgPruningPointProofToDomainPruningPointProof converts *MsgPruningPointProof to *externalapi.PruningPointProof
+func MsgPruningPointProofToDomainPruningPointProof(pruningPointProofMessage *MsgPruningPointProof) *externalapi.PruningPointProof {
+	headers := make([]externalapi.BlockHeader, len(pruningPointProofMessage.Headers))
+	for i, header := range pruningPointProofMessage.Headers {
+		headers[i] = BlockHeaderToDomainBlockHeader(header)
+	}
+	return &externalapi.PruningPointProof{
+		Headers:              headers,
+		PruningPointBlueWork: pruningPointProofMessage.PruningPointBlueWork,
+	}
+}
+
+// DomainPruningPointProofToMsgPruningPointProof converts *externalapi.PruningPointProof to *MsgPruningPointProof
+func DomainPruningPointProofToMsgPruningPointProof(pruningPointProof *externalapi.PruningPointProof) *MsgPruningPointProof {
+	headers := make([]*MsgBlockHeader, len(pruningPointProof.Headers))
+	for i, header := range pruningPointProof.Headers {
+		headers[i] = DomainBlockHeaderToBlockHeader(header)
+	}
+	return &MsgPruningPointProof{
+		Headers:              headers,
+		PruningPointBlueWork: pruningPointProof.PruningPointBlueWork,
+	}
+}

app/appmessage/message.go

@@ -66,6 +66,8 @@ const (
 	CmdIBDBlock
 	CmdRequestIBDBlocks
 	CmdPruningPoints
+	CmdRequestPruningPointProof
+	CmdPruningPointProof
 
 	// rpc
 	CmdGetCurrentNetworkRequestMessage
@@ -185,6 +187,8 @@ var ProtocolMessageCommandToString = map[MessageCommand]string{
 	CmdIBDBlock:                            "IBDBlock",
 	CmdRequestIBDBlocks:                    "RequestIBDBlocks",
 	CmdPruningPoints:                       "PruningPoints",
+	CmdRequestPruningPointProof:            "RequestPruningPointProof",
+	CmdPruningPointProof:                   "PruningPointProof",
 }
 
 // RPCMessageCommandToString maps all MessageCommands to their string representation

app/appmessage/p2p_msgpruningpointproof.go

@@ -0,0 +1,24 @@
+package appmessage
+
+import "math/big"
+
+// MsgPruningPointProof represents a kaspa PruningPointProof message
+type MsgPruningPointProof struct {
+	baseMessage
+
+	Headers              []*MsgBlockHeader
+	PruningPointBlueWork *big.Int
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgPruningPointProof) Command() MessageCommand {
+	return CmdPruningPointProof
+}
+
+// NewMsgPruningPointProof returns a new MsgPruningPointProof.
+func NewMsgPruningPointProof(headers []*MsgBlockHeader, pruningPointBlueWork *big.Int) *MsgPruningPointProof {
+	return &MsgPruningPointProof{
+		Headers:              headers,
+		PruningPointBlueWork: pruningPointBlueWork,
+	}
+}

app/appmessage/p2p_msgrequestpruningpointproof.go

@@ -0,0 +1,16 @@
+package appmessage
+
+// MsgRequestPruningPointProof represents a kaspa RequestPruningPointProof message
+type MsgRequestPruningPointProof struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgRequestPruningPointProof) Command() MessageCommand {
+	return CmdRequestPruningPointProof
+}
+
+// NewMsgRequestPruningPointProof returns a new MsgRequestPruningPointProof.
+func NewMsgRequestPruningPointProof() *MsgRequestPruningPointProof {
+	return &MsgRequestPruningPointProof{}
+}

app/protocol/flows/blockrelay/handle_pruning_point_proof_requests.go

@@ -0,0 +1,40 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// PruningPointProofRequestsContext is the interface for the context needed for the HandlePruningPointProofRequests flow.
+type PruningPointProofRequestsContext interface {
+	Domain() domain.Domain
+}
+
+// HandlePruningPointProofRequests listens to appmessage.MsgRequestPruningPointProof messages and sends
+// the pruning point proof to the requesting peer.
+func HandlePruningPointProofRequests(context PruningPointProofRequestsContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
+
+	for {
+		_, err := incomingRoute.Dequeue()
+		if err != nil {
+			return err
+		}
+
+		log.Debugf("Got request for pruning point proof from %s", peer)
+
+		pruningPointProof, err := context.Domain().Consensus().BuildPruningPointProof()
+		if err != nil {
+			return err
+		}
+		pruningPointProofMessage := appmessage.DomainPruningPointProofToMsgPruningPointProof(pruningPointProof)
+		err = outgoingRoute.Enqueue(pruningPointProofMessage)
+		if err != nil {
+			return err
+		}
+
+		log.Debugf("Sent pruning point proof to %s", peer)
+	}
+}

app/protocol/flows/blockrelay/ibd_with_headers_proof.go

@@ -8,6 +8,7 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/pkg/errors"
+	"math/big"
 )
 
 func (flow *handleRelayInvsFlow) ibdWithHeadersProof(highHash *externalapi.DomainHash) error {
@@ -88,37 +89,63 @@ func (flow *handleRelayInvsFlow) checkIfHighHashHasMoreBlueWorkThanSelectedTip(h
 	return msgBlockBlueWork.BlueWork.Cmp(headersSelectedTipInfo.BlueWork) > 0, nil
 }
 
-func (flow *handleRelayInvsFlow) downloadHeadersProof() error {
-	// TODO: Implement headers proof mechanism
-	return nil
+func (flow *handleRelayInvsFlow) syncAndValidatePruningPointProof() (*big.Int, error) {
+	log.Infof("Downloading the pruning point proof from %s", flow.peer)
+	err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestPruningPointProof())
+	if err != nil {
+		return nil, err
+	}
+	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
+	if err != nil {
+		return nil, err
+	}
+	pruningPointProofMessage, ok := message.(*appmessage.MsgPruningPointProof)
+	if !ok {
+		return nil, protocolerrors.Errorf(true, "received unexpected message type. "+
+			"expected: %s, got: %s", appmessage.CmdPruningPointProof, message.Command())
+	}
+	pruningPointProof := appmessage.MsgPruningPointProofToDomainPruningPointProof(pruningPointProofMessage)
+	err = flow.Domain().Consensus().ValidatePruningPointProof(pruningPointProof)
+	if err != nil {
+		return nil, err
+	}
+	return pruningPointProof.PruningPointBlueWork, nil
 }
 
 func (flow *handleRelayInvsFlow) downloadHeadersAndPruningUTXOSet(highHash *externalapi.DomainHash) error {
-	err := flow.downloadHeadersProof()
+	pruningPointBlueWork, err := flow.syncAndValidatePruningPointProof()
 	if err != nil {
 		return err
 	}
 
-	pruningPoint, err := flow.syncPruningPointsAndPruningPointAnticone()
+	pruningPointHash, err := flow.syncPruningPointsAndPruningPointAnticone()
 	if err != nil {
 		return err
 	}
+	pruningPointHeader, err := flow.Domain().Consensus().GetBlockHeader(pruningPointHash)
+	if err != nil {
+		return err
+	}
+	if pruningPointHeader.BlueWork().Cmp(pruningPointBlueWork) != 0 {
+		return protocolerrors.Errorf(true, "pruning point blue work in pruning point proof does "+
+			"not match the blue work declared in the pruning point header")
+	}
 
 	// TODO: Remove this condition once there's more proper way to check finality violation
 	// in the headers proof.
-	if pruningPoint.Equal(flow.Config().NetParams().GenesisHash) {
+	if pruningPointHash.Equal(flow.Config().NetParams().GenesisHash) {
 		return protocolerrors.Errorf(true, "the genesis pruning point violates finality")
 	}
 
-	err = flow.syncPruningPointFutureHeaders(flow.Domain().StagingConsensus(), pruningPoint, highHash)
+	err = flow.syncPruningPointFutureHeaders(flow.Domain().StagingConsensus(), pruningPointHash, highHash)
 	if err != nil {
 		return err
 	}
 
 	log.Debugf("Blocks downloaded from peer %s", flow.peer)
 
 	log.Debugf("Syncing the current pruning point UTXO set")
-	syncedPruningPointUTXOSetSuccessfully, err := flow.syncPruningPointUTXOSet(flow.Domain().StagingConsensus(), pruningPoint)
+	syncedPruningPointUTXOSetSuccessfully, err := flow.syncPruningPointUTXOSet(flow.Domain().StagingConsensus(), pruningPointHash)
 	if err != nil {
 		return err
 	}
@@ -131,7 +158,6 @@ func (flow *handleRelayInvsFlow) downloadHeadersAndPruningUTXOSet(highHash *exte
 }
 
 func (flow *handleRelayInvsFlow) syncPruningPointsAndPruningPointAnticone() (*externalapi.DomainHash, error) {
-
 	log.Infof("Downloading the past pruning points and the pruning point anticone from %s", flow.peer)
 	err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestPruningPointAndItsAnticone())
 	if err != nil {

app/protocol/protocol.go

@@ -173,6 +173,7 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 			appmessage.CmdBlockHeaders, appmessage.CmdIBDBlockLocatorHighestHash, appmessage.CmdBlockWithTrustedData,
 			appmessage.CmdDoneBlocksWithTrustedData, appmessage.CmdIBDBlockLocatorHighestHashNotFound,
 			appmessage.CmdDonePruningPointUTXOSetChunks, appmessage.CmdIBDBlock, appmessage.CmdPruningPoints,
+			appmessage.CmdPruningPointProof,
 		},
 			isStopping, errChan, func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
 				return blockrelay.HandleRelayInvs(m.context, incomingRoute,
@@ -235,6 +236,13 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 				return blockrelay.HandleIBDBlockLocator(m.context, incomingRoute, outgoingRoute, peer)
 			},
 		),
+
+		m.registerFlow("HandlePruningPointProofRequests", router,
+			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointProof}, isStopping, errChan,
+			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
+				return blockrelay.HandlePruningPointProofRequests(m.context, incomingRoute, outgoingRoute, peer)
+			},
+		),
 	}
 }
 

domain/consensus/consensus.go

@@ -722,3 +722,20 @@ func (s *consensus) ResolveVirtual() error {
 		}
 	}
 }
+
+func (s *consensus) BuildPruningPointProof() (*externalapi.PruningPointProof, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	return &externalapi.PruningPointProof{
+		Headers:              []externalapi.BlockHeader{},
+		PruningPointBlueWork: big.NewInt(0),
+	}, nil
+}
+
+func (s *consensus) ValidatePruningPointProof(pruningPointProof *externalapi.PruningPointProof) error {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	return nil
+}

domain/consensus/model/externalapi/consensus.go

@@ -8,6 +8,8 @@ type Consensus interface {
 	ValidateAndInsertBlockWithTrustedData(block *BlockWithTrustedData, validateUTXO bool) (*BlockInsertionResult, error)
 	ValidateTransactionAndPopulateWithConsensusData(transaction *DomainTransaction) error
 	ImportPruningPoints(pruningPoints []BlockHeader) error
+	BuildPruningPointProof() (*PruningPointProof, error)
+	ValidatePruningPointProof(pruningPointProof *PruningPointProof) error
 
 	GetBlock(blockHash *DomainHash) (*DomainBlock, error)
 	GetBlockEvenIfHeaderOnly(blockHash *DomainHash) (*DomainBlock, error)

domain/consensus/model/externalapi/pruning_point_proof.go

@@ -0,0 +1,9 @@
+package externalapi
+
+import "math/big"
+
+// PruningPointProof is the data structure holding the pruning point proof
+type PruningPointProof struct {
+	Headers              []BlockHeader
+	PruningPointBlueWork *big.Int
+}