Implement pruning point proof (#1832)

* Calculate GHOSTDAG, reachability etc for each level

* Don't preallocate cache for dag stores except level 0 and reduce the number of connections in the integration test to 32

* Reduce the number of connections in the integration test to 16

* Increase page file

* BuildPruningPointProof

* BuildPruningPointProof

* Add PruningProofManager

* Implement ApplyPruningPointProof

* Add prefix and fix blockAtDepth and fill headersByLevel

* Some bug fixes

* Include all relevant blocks for each level in the proof

* Fix syncAndValidatePruningPointProof to return the right block hash

* Fix block window

* Fix isAncestorOfPruningPoint

* Ban for rule errors on pruning proof

* Find common ancestor for blockAtDepthMAtNextLevel

* Use pruning proof in TestValidateAndInsertImportedPruningPoint

* stage status and finality point for proof blocks

* Uncomment golint

* Change test timeouts

* Calculate merge set for ApplyPruningPointProof

* Increase test timeout

* Add better caching for daa window store

* Return to default timeout

* Add ErrPruningProofMissesBlocksBelowPruningPoint

* Add errDAAWindowBlockNotFound

* Force connection loop next iteration on connection manager stop

* Revert to Test64IncomingConnections

* Remove BlockAtDepth from DAGTraversalManager

* numBullies->16

* Set page file size to 8gb

* Increase p2p max message size

* Test64IncomingConnections->Test16IncomingConnections

* Add comment for PruningProofM

* Add comment in `func (c *ConnectionManager) Stop()`

* Rename isAncestorOfPruningPoint->isAncestorOfSelectedTip

* Revert page file to 16gb

* Improve ExpectedHeaderPruningPoint perf

* Fix comment

* Revert "Improve ExpectedHeaderPruningPoint perf"

This reverts commit bca1080.

* Don't test windows

.github/workflows/tests.yaml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ ubuntu-latest, macos-latest, windows-latest ]
+        os: [ ubuntu-latest, macos-latest ]
     name: Tests, ${{ matrix.os }}
     steps:
 

app/protocol/flows/blockrelay/ibd.go

@@ -248,8 +248,8 @@ func (flow *handleRelayInvsFlow) syncPruningPointFutureHeaders(consensus externa
 				}
 				return nil
 			}
-			for _, block := range ibdBlocksMessage.BlockHeaders {
-				err = flow.processHeader(consensus, block)
+			for _, header := range ibdBlocksMessage.BlockHeaders {
+				err = flow.processHeader(consensus, header)
 				if err != nil {
 					return err
 				}

app/protocol/flows/blockrelay/ibd_with_headers_proof.go

@@ -7,6 +7,7 @@ import (
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/pkg/errors"
 )
 
@@ -71,51 +72,73 @@ func (flow *handleRelayInvsFlow) checkIfHighHashHasMoreBlueWorkThanSelectedTip(h
 	return highBlock.Header.BlueWork().Cmp(headersSelectedTipInfo.BlueWork) > 0, nil
 }
 
-func (flow *handleRelayInvsFlow) syncAndValidatePruningPointProof() error {
+func (flow *handleRelayInvsFlow) syncAndValidatePruningPointProof() (*externalapi.DomainHash, error) {
 	log.Infof("Downloading the pruning point proof from %s", flow.peer)
 	err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestPruningPointProof())
 	if err != nil {
-		return err
+		return nil, err
 	}
 	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	pruningPointProofMessage, ok := message.(*appmessage.MsgPruningPointProof)
 	if !ok {
-		return protocolerrors.Errorf(true, "received unexpected message type. "+
+		return nil, protocolerrors.Errorf(true, "received unexpected message type. "+
 			"expected: %s, got: %s", appmessage.CmdPruningPointProof, message.Command())
 	}
 	pruningPointProof := appmessage.MsgPruningPointProofToDomainPruningPointProof(pruningPointProofMessage)
-	return flow.Domain().Consensus().ValidatePruningPointProof(pruningPointProof)
+	err = flow.Domain().Consensus().ValidatePruningPointProof(pruningPointProof)
+	if err != nil {
+		if errors.As(err, &ruleerrors.RuleError{}) {
+			return nil, protocolerrors.Wrapf(true, err, "pruning point proof validation failed")
+		}
+		return nil, err
+	}
+
+	err = flow.Domain().StagingConsensus().ApplyPruningPointProof(pruningPointProof)
+	if err != nil {
+		return nil, err
+	}
+
+	return consensushashing.HeaderHash(pruningPointProof.Headers[0][len(pruningPointProof.Headers[0])-1]), nil
 }
 
 func (flow *handleRelayInvsFlow) downloadHeadersAndPruningUTXOSet(highHash *externalapi.DomainHash) error {
-	err := flow.syncAndValidatePruningPointProof()
+	proofPruningPoint, err := flow.syncAndValidatePruningPointProof()
 	if err != nil {
 		return err
 	}
 
-	pruningPoint, err := flow.syncPruningPointsAndPruningPointAnticone()
+	err = flow.syncPruningPointsAndPruningPointAnticone(proofPruningPoint)
 	if err != nil {
 		return err
 	}
 
 	// 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 proofPruningPoint.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(), proofPruningPoint, highHash)
+	if err != nil {
+		return err
+	}
+
+	log.Debugf("Headers downloaded from peer %s", flow.peer)
+
+	highHashInfo, err := flow.Domain().StagingConsensus().GetBlockInfo(highHash)
 	if err != nil {
 		return err
 	}
 
-	log.Debugf("Blocks downloaded from peer %s", flow.peer)
+	if !highHashInfo.Exists {
+		return protocolerrors.Errorf(true, "the triggering IBD block was not sent")
+	}
 
 	log.Debugf("Syncing the current pruning point UTXO set")
-	syncedPruningPointUTXOSetSuccessfully, err := flow.syncPruningPointUTXOSet(flow.Domain().StagingConsensus(), pruningPoint)
+	syncedPruningPointUTXOSetSuccessfully, err := flow.syncPruningPointUTXOSet(flow.Domain().StagingConsensus(), proofPruningPoint)
 	if err != nil {
 		return err
 	}
@@ -127,36 +150,40 @@ func (flow *handleRelayInvsFlow) downloadHeadersAndPruningUTXOSet(highHash *exte
 	return nil
 }
 
-func (flow *handleRelayInvsFlow) syncPruningPointsAndPruningPointAnticone() (*externalapi.DomainHash, error) {
+func (flow *handleRelayInvsFlow) syncPruningPointsAndPruningPointAnticone(proofPruningPoint *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 {
-		return nil, err
+		return err
 	}
 
-	err = flow.validateAndInsertPruningPoints()
+	err = flow.validateAndInsertPruningPoints(proofPruningPoint)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	pruningPoint, done, err := flow.receiveBlockWithTrustedData()
+	pruningPointWithMetaData, done, err := flow.receiveBlockWithTrustedData()
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	if done {
-		return nil, protocolerrors.Errorf(true, "got `done` message before receiving the pruning point")
+		return protocolerrors.Errorf(true, "got `done` message before receiving the pruning point")
 	}
 
-	err = flow.processBlockWithTrustedData(flow.Domain().StagingConsensus(), pruningPoint)
+	if !pruningPointWithMetaData.Block.Header.BlockHash().Equal(proofPruningPoint) {
+		return protocolerrors.Errorf(true, "first block with trusted data is not the pruning point")
+	}
+
+	err = flow.processBlockWithTrustedData(flow.Domain().StagingConsensus(), pruningPointWithMetaData)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	for {
 		blockWithTrustedData, done, err := flow.receiveBlockWithTrustedData()
 		if err != nil {
-			return nil, err
+			return err
 		}
 
 		if done {
@@ -165,12 +192,12 @@ func (flow *handleRelayInvsFlow) syncPruningPointsAndPruningPointAnticone() (*ex
 
 		err = flow.processBlockWithTrustedData(flow.Domain().StagingConsensus(), blockWithTrustedData)
 		if err != nil {
-			return nil, err
+			return err
 		}
 	}
 
 	log.Infof("Finished downloading pruning point and its anticone from %s", flow.peer)
-	return pruningPoint.Block.Header.BlockHash(), nil
+	return nil
 }
 
 func (flow *handleRelayInvsFlow) processBlockWithTrustedData(
@@ -217,7 +244,16 @@ func (flow *handleRelayInvsFlow) receivePruningPoints() (*appmessage.MsgPruningP
 	return msgPruningPoints, nil
 }
 
-func (flow *handleRelayInvsFlow) validateAndInsertPruningPoints() error {
+func (flow *handleRelayInvsFlow) validateAndInsertPruningPoints(proofPruningPoint *externalapi.DomainHash) error {
+	currentPruningPoint, err := flow.Domain().Consensus().PruningPoint()
+	if err != nil {
+		return err
+	}
+
+	if currentPruningPoint.Equal(proofPruningPoint) {
+		return protocolerrors.Errorf(true, "the proposed pruning point is the same as the current pruning point")
+	}
+
 	pruningPoints, err := flow.receivePruningPoints()
 	if err != nil {
 		return err
@@ -238,6 +274,12 @@ func (flow *handleRelayInvsFlow) validateAndInsertPruningPoints() error {
 		return protocolerrors.Errorf(false, "pruning points are violating finality")
 	}
 
+	lastPruningPoint := consensushashing.HeaderHash(headers[len(headers)-1])
+	if !lastPruningPoint.Equal(proofPruningPoint) {
+		return protocolerrors.Errorf(true, "the proof pruning point is not equal to the last pruning "+
+			"point in the list")
+	}
+
 	err = flow.Domain().StagingConsensus().ImportPruningPoints(headers)
 	if err != nil {
 		return err