Remove increase pagefile

.github/workflows/deploy.yaml

@@ -19,11 +19,6 @@ jobs:
       - name: Check out code into the Go module directory
         uses: actions/checkout@v2
 
-      # Increase the pagefile size on Windows to aviod running out of memory
-      - name: Increase pagefile size on Windows
-        if: runner.os == 'Windows'
-        run: powershell -command .github\workflows\SetPageFileSize.ps1
-
 
       - name: Setup Go
         uses: actions/setup-go@v2

app/protocol/flows/handshake/receiveversion.go

@@ -18,7 +18,7 @@ var (
 
 	// minAcceptableProtocolVersion is the lowest protocol version that a
 	// connected peer may support.
-	minAcceptableProtocolVersion = uint32(4)
+	minAcceptableProtocolVersion = uint32(5)
 
 	maxAcceptableProtocolVersion = uint32(5)
 )

app/protocol/flows/v4/addressexchange/receiveaddresses.go

@@ -1,39 +0,0 @@
-package addressexchange
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// ReceiveAddressesContext is the interface for the context needed for the ReceiveAddresses flow.
-type ReceiveAddressesContext interface {
-	AddressManager() *addressmanager.AddressManager
-}
-
-// ReceiveAddresses asks a peer for more addresses if needed.
-func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route,
-	peer *peerpkg.Peer) error {
-
-	subnetworkID := peer.SubnetworkID()
-	msgGetAddresses := appmessage.NewMsgRequestAddresses(false, subnetworkID)
-	err := outgoingRoute.Enqueue(msgGetAddresses)
-	if err != nil {
-		return err
-	}
-
-	message, err := incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-	if err != nil {
-		return err
-	}
-
-	msgAddresses := message.(*appmessage.MsgAddresses)
-	if len(msgAddresses.AddressList) > addressmanager.GetAddressesMax {
-		return protocolerrors.Errorf(true, "address count exceeded %d", addressmanager.GetAddressesMax)
-	}
-
-	return context.AddressManager().AddAddresses(msgAddresses.AddressList...)
-}

app/protocol/flows/v4/addressexchange/sendaddresses.go

@@ -1,52 +0,0 @@
-package addressexchange
-
-import (
-	"math/rand"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// SendAddressesContext is the interface for the context needed for the SendAddresses flow.
-type SendAddressesContext interface {
-	AddressManager() *addressmanager.AddressManager
-}
-
-// SendAddresses sends addresses to a peer that requests it.
-func SendAddresses(context SendAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
-	for {
-		_, err := incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-
-		addresses := context.AddressManager().Addresses()
-		msgAddresses := appmessage.NewMsgAddresses(shuffleAddresses(addresses))
-
-		err = outgoingRoute.Enqueue(msgAddresses)
-		if err != nil {
-			return err
-		}
-	}
-}
-
-// shuffleAddresses randomizes the given addresses sent if there are more than the maximum allowed in one message.
-func shuffleAddresses(addresses []*appmessage.NetAddress) []*appmessage.NetAddress {
-	addressCount := len(addresses)
-
-	if addressCount < appmessage.MaxAddressesPerMsg {
-		return addresses
-	}
-
-	shuffleAddresses := make([]*appmessage.NetAddress, addressCount)
-	copy(shuffleAddresses, addresses)
-
-	rand.Shuffle(addressCount, func(i, j int) {
-		shuffleAddresses[i], shuffleAddresses[j] = shuffleAddresses[j], shuffleAddresses[i]
-	})
-
-	// Truncate it to the maximum size.
-	shuffleAddresses = shuffleAddresses[:appmessage.MaxAddressesPerMsg]
-	return shuffleAddresses
-}

app/protocol/flows/v4/blockrelay/batch_size_test.go

@@ -1,16 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"testing"
-)
-
-func TestIBDBatchSizeLessThanRouteCapacity(t *testing.T) {
-	// The `ibdBatchSize` constant must be equal at both syncer and syncee. Therefore, we do not want
-	// to set it to `router.DefaultMaxMessages` to avoid confusion and human errors.
-	// However, nonetheless we must enforce that it does not exceed `router.DefaultMaxMessages`
-	if ibdBatchSize > router.DefaultMaxMessages {
-		t.Fatalf("IBD batch size (%d) must be smaller than or equal to router.DefaultMaxMessages (%d)",
-			ibdBatchSize, router.DefaultMaxMessages)
-	}
-}

app/protocol/flows/v4/blockrelay/block_locator.go

@@ -1,33 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-func (flow *handleRelayInvsFlow) sendGetBlockLocator(highHash *externalapi.DomainHash, limit uint32) error {
-	msgGetBlockLocator := appmessage.NewMsgRequestBlockLocator(highHash, limit)
-	return flow.outgoingRoute.Enqueue(msgGetBlockLocator)
-}
-
-func (flow *handleRelayInvsFlow) receiveBlockLocator() (blockLocatorHashes []*externalapi.DomainHash, err error) {
-	for {
-		message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-		if err != nil {
-			return nil, err
-		}
-
-		switch message := message.(type) {
-		case *appmessage.MsgInvRelayBlock:
-			flow.invsQueue = append(flow.invsQueue, message)
-		case *appmessage.MsgBlockLocator:
-			return message.BlockLocatorHashes, nil
-		default:
-			return nil,
-				protocolerrors.Errorf(true, "received unexpected message type. "+
-					"expected: %s, got: %s", appmessage.CmdBlockLocator, message.Command())
-		}
-	}
-}

app/protocol/flows/v4/blockrelay/handle_ibd_block_locator.go

@@ -1,86 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleIBDBlockLocatorContext is the interface for the context needed for the HandleIBDBlockLocator flow.
-type HandleIBDBlockLocatorContext interface {
-	Domain() domain.Domain
-}
-
-// HandleIBDBlockLocator listens to appmessage.MsgIBDBlockLocator messages and sends
-// the highest known block that's in the selected parent chain of `targetHash` to the
-// requesting peer.
-func HandleIBDBlockLocator(context HandleIBDBlockLocatorContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route, peer *peer.Peer) error {
-
-	for {
-		message, err := incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-		ibdBlockLocatorMessage := message.(*appmessage.MsgIBDBlockLocator)
-
-		targetHash := ibdBlockLocatorMessage.TargetHash
-		log.Debugf("Received IBDBlockLocator from %s with targetHash %s", peer, targetHash)
-
-		blockInfo, err := context.Domain().Consensus().GetBlockInfo(targetHash)
-		if err != nil {
-			return err
-		}
-		if !blockInfo.Exists {
-			return protocolerrors.Errorf(true, "received IBDBlockLocator "+
-				"with an unknown targetHash %s", targetHash)
-		}
-
-		foundHighestHashInTheSelectedParentChainOfTargetHash := false
-		for _, blockLocatorHash := range ibdBlockLocatorMessage.BlockLocatorHashes {
-			blockInfo, err := context.Domain().Consensus().GetBlockInfo(blockLocatorHash)
-			if err != nil {
-				return err
-			}
-
-			// The IBD block locator is checking only existing blocks with bodies.
-			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
-				continue
-			}
-
-			isBlockLocatorHashInSelectedParentChainOfHighHash, err :=
-				context.Domain().Consensus().IsInSelectedParentChainOf(blockLocatorHash, targetHash)
-			if err != nil {
-				return err
-			}
-			if !isBlockLocatorHashInSelectedParentChainOfHighHash {
-				continue
-			}
-
-			foundHighestHashInTheSelectedParentChainOfTargetHash = true
-			log.Debugf("Found a known hash %s amongst peer %s's "+
-				"blockLocator that's in the selected parent chain of targetHash %s", blockLocatorHash, peer, targetHash)
-
-			ibdBlockLocatorHighestHashMessage := appmessage.NewMsgIBDBlockLocatorHighestHash(blockLocatorHash)
-			err = outgoingRoute.Enqueue(ibdBlockLocatorHighestHashMessage)
-			if err != nil {
-				return err
-			}
-			break
-		}
-
-		if !foundHighestHashInTheSelectedParentChainOfTargetHash {
-			log.Warnf("no hash was found in the blockLocator "+
-				"that was in the selected parent chain of targetHash %s", targetHash)
-
-			ibdBlockLocatorHighestHashNotFoundMessage := appmessage.NewMsgIBDBlockLocatorHighestHashNotFound()
-			err = outgoingRoute.Enqueue(ibdBlockLocatorHighestHashNotFoundMessage)
-			if err != nil {
-				return err
-			}
-		}
-	}
-}

app/protocol/flows/v4/blockrelay/handle_ibd_block_requests.go

@@ -1,54 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/pkg/errors"
-)
-
-// HandleIBDBlockRequestsContext is the interface for the context needed for the HandleIBDBlockRequests flow.
-type HandleIBDBlockRequestsContext interface {
-	Domain() domain.Domain
-}
-
-// HandleIBDBlockRequests listens to appmessage.MsgRequestRelayBlocks messages and sends
-// their corresponding blocks to the requesting peer.
-func HandleIBDBlockRequests(context HandleIBDBlockRequestsContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route) error {
-
-	for {
-		message, err := incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-		msgRequestIBDBlocks := message.(*appmessage.MsgRequestIBDBlocks)
-		log.Debugf("Got request for %d ibd blocks", len(msgRequestIBDBlocks.Hashes))
-		for i, hash := range msgRequestIBDBlocks.Hashes {
-			// Fetch the block from the database.
-			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
-			if err != nil {
-				return err
-			}
-			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
-				return protocolerrors.Errorf(true, "block %s not found (v4)", hash)
-			}
-			block, err := context.Domain().Consensus().GetBlock(hash)
-			if err != nil {
-				return errors.Wrapf(err, "unable to fetch requested block hash %s", hash)
-			}
-
-			// TODO (Partial nodes): Convert block to partial block if needed
-
-			blockMessage := appmessage.DomainBlockToMsgBlock(block)
-			ibdBlockMessage := appmessage.NewMsgIBDBlock(blockMessage)
-			err = outgoingRoute.Enqueue(ibdBlockMessage)
-			if err != nil {
-				return err
-			}
-			log.Debugf("sent %d out of %d", i+1, len(msgRequestIBDBlocks.Hashes))
-		}
-	}
-}

app/protocol/flows/v4/blockrelay/handle_pruning_point_and_its_anticone_requests.go

@@ -1,145 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"sync/atomic"
-)
-
-// PruningPointAndItsAnticoneRequestsContext is the interface for the context needed for the HandlePruningPointAndItsAnticoneRequests flow.
-type PruningPointAndItsAnticoneRequestsContext interface {
-	Domain() domain.Domain
-	Config() *config.Config
-}
-
-var isBusy uint32
-
-// HandlePruningPointAndItsAnticoneRequests listens to appmessage.MsgRequestPruningPointAndItsAnticone messages and sends
-// the pruning point and its anticone to the requesting peer.
-func HandlePruningPointAndItsAnticoneRequests(context PruningPointAndItsAnticoneRequestsContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
-
-	for {
-		err := func() error {
-			_, err := incomingRoute.Dequeue()
-			if err != nil {
-				return err
-			}
-
-			if !atomic.CompareAndSwapUint32(&isBusy, 0, 1) {
-				return protocolerrors.Errorf(false, "node is busy with other pruning point anticone requests")
-			}
-			defer atomic.StoreUint32(&isBusy, 0)
-
-			log.Debugf("Got request for pruning point and its anticone from %s", peer)
-
-			pruningPointHeaders, err := context.Domain().Consensus().PruningPointHeaders()
-			if err != nil {
-				return err
-			}
-
-			msgPruningPointHeaders := make([]*appmessage.MsgBlockHeader, len(pruningPointHeaders))
-			for i, header := range pruningPointHeaders {
-				msgPruningPointHeaders[i] = appmessage.DomainBlockHeaderToBlockHeader(header)
-			}
-
-			err = outgoingRoute.Enqueue(appmessage.NewMsgPruningPoints(msgPruningPointHeaders))
-			if err != nil {
-				return err
-			}
-
-			pointAndItsAnticone, err := context.Domain().Consensus().PruningPointAndItsAnticone()
-			if err != nil {
-				return err
-			}
-
-			windowSize := context.Config().NetParams().DifficultyAdjustmentWindowSize
-			daaWindowBlocks := make([]*externalapi.TrustedDataDataDAAHeader, 0, windowSize)
-			daaWindowHashesToIndex := make(map[externalapi.DomainHash]int, windowSize)
-			trustedDataDAABlockIndexes := make(map[externalapi.DomainHash][]uint64)
-
-			ghostdagData := make([]*externalapi.BlockGHOSTDAGDataHashPair, 0)
-			ghostdagDataHashToIndex := make(map[externalapi.DomainHash]int)
-			trustedDataGHOSTDAGDataIndexes := make(map[externalapi.DomainHash][]uint64)
-			for _, blockHash := range pointAndItsAnticone {
-				blockDAAWindowHashes, err := context.Domain().Consensus().BlockDAAWindowHashes(blockHash)
-				if err != nil {
-					return err
-				}
-
-				trustedDataDAABlockIndexes[*blockHash] = make([]uint64, 0, windowSize)
-				for i, daaBlockHash := range blockDAAWindowHashes {
-					index, exists := daaWindowHashesToIndex[*daaBlockHash]
-					if !exists {
-						trustedDataDataDAAHeader, err := context.Domain().Consensus().TrustedDataDataDAAHeader(blockHash, daaBlockHash, uint64(i))
-						if err != nil {
-							return err
-						}
-						daaWindowBlocks = append(daaWindowBlocks, trustedDataDataDAAHeader)
-						index = len(daaWindowBlocks) - 1
-						daaWindowHashesToIndex[*daaBlockHash] = index
-					}
-
-					trustedDataDAABlockIndexes[*blockHash] = append(trustedDataDAABlockIndexes[*blockHash], uint64(index))
-				}
-
-				ghostdagDataBlockHashes, err := context.Domain().Consensus().TrustedBlockAssociatedGHOSTDAGDataBlockHashes(blockHash)
-				if err != nil {
-					return err
-				}
-
-				trustedDataGHOSTDAGDataIndexes[*blockHash] = make([]uint64, 0, context.Config().NetParams().K)
-				for _, ghostdagDataBlockHash := range ghostdagDataBlockHashes {
-					index, exists := ghostdagDataHashToIndex[*ghostdagDataBlockHash]
-					if !exists {
-						data, err := context.Domain().Consensus().TrustedGHOSTDAGData(ghostdagDataBlockHash)
-						if err != nil {
-							return err
-						}
-						ghostdagData = append(ghostdagData, &externalapi.BlockGHOSTDAGDataHashPair{
-							Hash:         ghostdagDataBlockHash,
-							GHOSTDAGData: data,
-						})
-						index = len(ghostdagData) - 1
-						ghostdagDataHashToIndex[*ghostdagDataBlockHash] = index
-					}
-
-					trustedDataGHOSTDAGDataIndexes[*blockHash] = append(trustedDataGHOSTDAGDataIndexes[*blockHash], uint64(index))
-				}
-			}
-
-			err = outgoingRoute.Enqueue(appmessage.DomainTrustedDataToTrustedData(daaWindowBlocks, ghostdagData))
-			if err != nil {
-				return err
-			}
-
-			for _, blockHash := range pointAndItsAnticone {
-				block, err := context.Domain().Consensus().GetBlock(blockHash)
-				if err != nil {
-					return err
-				}
-
-				err = outgoingRoute.Enqueue(appmessage.DomainBlockWithTrustedDataToBlockWithTrustedDataV4(block, trustedDataDAABlockIndexes[*blockHash], trustedDataGHOSTDAGDataIndexes[*blockHash]))
-				if err != nil {
-					return err
-				}
-			}
-
-			err = outgoingRoute.Enqueue(appmessage.NewMsgDoneBlocksWithTrustedData())
-			if err != nil {
-				return err
-			}
-
-			log.Debugf("Sent pruning point and its anticone to %s", peer)
-			return nil
-		}()
-		if err != nil {
-			return err
-		}
-	}
-}

app/protocol/flows/v4/blockrelay/handle_pruning_point_proof_requests.go

@@ -1,40 +0,0 @@
-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/v4/blockrelay/handle_relay_block_requests.go

@@ -1,53 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/pkg/errors"
-)
-
-// RelayBlockRequestsContext is the interface for the context needed for the HandleRelayBlockRequests flow.
-type RelayBlockRequestsContext interface {
-	Domain() domain.Domain
-}
-
-// HandleRelayBlockRequests listens to appmessage.MsgRequestRelayBlocks messages and sends
-// their corresponding blocks to the requesting peer.
-func HandleRelayBlockRequests(context RelayBlockRequestsContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
-
-	for {
-		message, err := incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-		getRelayBlocksMessage := message.(*appmessage.MsgRequestRelayBlocks)
-		log.Debugf("Got request for relay blocks with hashes %s", getRelayBlocksMessage.Hashes)
-		for _, hash := range getRelayBlocksMessage.Hashes {
-			// Fetch the block from the database.
-			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
-			if err != nil {
-				return err
-			}
-			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
-				return protocolerrors.Errorf(true, "block %s not found", hash)
-			}
-			block, err := context.Domain().Consensus().GetBlock(hash)
-			if err != nil {
-				return errors.Wrapf(err, "unable to fetch requested block hash %s", hash)
-			}
-
-			// TODO (Partial nodes): Convert block to partial block if needed
-
-			err = outgoingRoute.Enqueue(appmessage.DomainBlockToMsgBlock(block))
-			if err != nil {
-				return err
-			}
-			log.Debugf("Relayed block with hash %s", hash)
-		}
-	}
-}

app/protocol/flows/v4/blockrelay/handle_relay_invs.go

@@ -1,433 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	"github.com/kaspanet/kaspad/app/protocol/flowcontext"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"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/kaspanet/kaspad/domain/consensus/utils/hashset"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/pkg/errors"
-)
-
-// orphanResolutionRange is the maximum amount of blockLocator hashes
-// to search for known blocks. See isBlockInOrphanResolutionRange for
-// further details
-var orphanResolutionRange uint32 = 5
-
-// RelayInvsContext is the interface for the context needed for the HandleRelayInvs flow.
-type RelayInvsContext interface {
-	Domain() domain.Domain
-	Config() *config.Config
-	OnNewBlock(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error
-	OnVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error
-	OnNewBlockTemplate() error
-	OnPruningPointUTXOSetOverride() error
-	SharedRequestedBlocks() *flowcontext.SharedRequestedBlocks
-	Broadcast(message appmessage.Message) error
-	AddOrphan(orphanBlock *externalapi.DomainBlock)
-	GetOrphanRoots(orphanHash *externalapi.DomainHash) ([]*externalapi.DomainHash, bool, error)
-	IsOrphan(blockHash *externalapi.DomainHash) bool
-	IsIBDRunning() bool
-	IsRecoverableError(err error) bool
-	IsNearlySynced() (bool, error)
-}
-
-type handleRelayInvsFlow struct {
-	RelayInvsContext
-	incomingRoute, outgoingRoute *router.Route
-	peer                         *peerpkg.Peer
-	invsQueue                    []*appmessage.MsgInvRelayBlock
-}
-
-// HandleRelayInvs listens to appmessage.MsgInvRelayBlock messages, requests their corresponding blocks if they
-// are missing, adds them to the DAG and propagates them to the rest of the network.
-func HandleRelayInvs(context RelayInvsContext, incomingRoute *router.Route, outgoingRoute *router.Route,
-	peer *peerpkg.Peer) error {
-
-	flow := &handleRelayInvsFlow{
-		RelayInvsContext: context,
-		incomingRoute:    incomingRoute,
-		outgoingRoute:    outgoingRoute,
-		peer:             peer,
-		invsQueue:        make([]*appmessage.MsgInvRelayBlock, 0),
-	}
-	err := flow.start()
-	// Currently, HandleRelayInvs flow is the only place where IBD is triggered, so the channel can be closed now
-	close(peer.IBDRequestChannel())
-	return err
-}
-
-func (flow *handleRelayInvsFlow) start() error {
-	for {
-		log.Debugf("Waiting for inv")
-		inv, err := flow.readInv()
-		if err != nil {
-			return err
-		}
-
-		log.Debugf("Got relay inv for block %s", inv.Hash)
-
-		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(inv.Hash)
-		if err != nil {
-			return err
-		}
-		if blockInfo.Exists && blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
-			if blockInfo.BlockStatus == externalapi.StatusInvalid {
-				return protocolerrors.Errorf(true, "sent inv of an invalid block %s",
-					inv.Hash)
-			}
-			log.Debugf("Block %s already exists. continuing...", inv.Hash)
-			continue
-		}
-
-		isGenesisVirtualSelectedParent, err := flow.isGenesisVirtualSelectedParent()
-		if err != nil {
-			return err
-		}
-
-		if flow.IsOrphan(inv.Hash) {
-			if flow.Config().NetParams().DisallowDirectBlocksOnTopOfGenesis && !flow.Config().AllowSubmitBlockWhenNotSynced && isGenesisVirtualSelectedParent {
-				log.Infof("Cannot process orphan %s for a node with only the genesis block. The node needs to IBD "+
-					"to the recent pruning point before normal operation can resume.", inv.Hash)
-				continue
-			}
-
-			log.Debugf("Block %s is a known orphan. Requesting its missing ancestors", inv.Hash)
-			err := flow.AddOrphanRootsToQueue(inv.Hash)
-			if err != nil {
-				return err
-			}
-			continue
-		}
-
-		// Block relay is disabled if the node is already during IBD AND considered out of sync
-		if flow.IsIBDRunning() {
-			isNearlySynced, err := flow.IsNearlySynced()
-			if err != nil {
-				return err
-			}
-			if !isNearlySynced {
-				log.Debugf("Got block %s while in IBD and the node is out of sync. Continuing...", inv.Hash)
-				continue
-			}
-		}
-
-		log.Debugf("Requesting block %s", inv.Hash)
-		block, exists, err := flow.requestBlock(inv.Hash)
-		if err != nil {
-			return err
-		}
-		if exists {
-			log.Debugf("Aborting requesting block %s because it already exists", inv.Hash)
-			continue
-		}
-
-		err = flow.banIfBlockIsHeaderOnly(block)
-		if err != nil {
-			return err
-		}
-
-		if flow.Config().NetParams().DisallowDirectBlocksOnTopOfGenesis && !flow.Config().AllowSubmitBlockWhenNotSynced && !flow.Config().Devnet && flow.isChildOfGenesis(block) {
-			log.Infof("Cannot process %s because it's a direct child of genesis.", consensushashing.BlockHash(block))
-			continue
-		}
-
-		log.Debugf("Processing block %s", inv.Hash)
-		oldVirtualInfo, err := flow.Domain().Consensus().GetVirtualInfo()
-		if err != nil {
-			return err
-		}
-		missingParents, virtualChangeSet, err := flow.processBlock(block)
-		if err != nil {
-			if errors.Is(err, ruleerrors.ErrPrunedBlock) {
-				log.Infof("Ignoring pruned block %s", inv.Hash)
-				continue
-			}
-
-			if errors.Is(err, ruleerrors.ErrDuplicateBlock) {
-				log.Infof("Ignoring duplicate block %s", inv.Hash)
-				continue
-			}
-			return err
-		}
-		if len(missingParents) > 0 {
-			log.Debugf("Block %s is orphan and has missing parents: %s", inv.Hash, missingParents)
-			err := flow.processOrphan(block)
-			if err != nil {
-				return err
-			}
-			continue
-		}
-
-		oldVirtualParents := hashset.New()
-		for _, parent := range oldVirtualInfo.ParentHashes {
-			oldVirtualParents.Add(parent)
-		}
-
-		newVirtualInfo, err := flow.Domain().Consensus().GetVirtualInfo()
-		if err != nil {
-			return err
-		}
-
-		virtualHasNewParents := false
-		for _, parent := range newVirtualInfo.ParentHashes {
-			if oldVirtualParents.Contains(parent) {
-				continue
-			}
-			virtualHasNewParents = true
-			block, err := flow.Domain().Consensus().GetBlock(parent)
-			if err != nil {
-				return err
-			}
-			blockHash := consensushashing.BlockHash(block)
-			log.Debugf("Relaying block %s", blockHash)
-			err = flow.relayBlock(block)
-			if err != nil {
-				return err
-			}
-		}
-
-		if virtualHasNewParents {
-			log.Debugf("Virtual %d has new parents, raising new block template event", newVirtualInfo.DAAScore)
-			err = flow.OnNewBlockTemplate()
-			if err != nil {
-				return err
-			}
-		}
-
-		log.Infof("Accepted block %s via relay", inv.Hash)
-		err = flow.OnNewBlock(block, virtualChangeSet)
-		if err != nil {
-			return err
-		}
-	}
-}
-
-func (flow *handleRelayInvsFlow) banIfBlockIsHeaderOnly(block *externalapi.DomainBlock) error {
-	if len(block.Transactions) == 0 {
-		return protocolerrors.Errorf(true, "sent header of %s block where expected block with body",
-			consensushashing.BlockHash(block))
-	}
-
-	return nil
-}
-
-func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error) {
-	if len(flow.invsQueue) > 0 {
-		var inv *appmessage.MsgInvRelayBlock
-		inv, flow.invsQueue = flow.invsQueue[0], flow.invsQueue[1:]
-		return inv, nil
-	}
-
-	msg, err := flow.incomingRoute.Dequeue()
-	if err != nil {
-		return nil, err
-	}
-
-	inv, ok := msg.(*appmessage.MsgInvRelayBlock)
-	if !ok {
-		return nil, protocolerrors.Errorf(true, "unexpected %s message in the block relay handleRelayInvsFlow while "+
-			"expecting an inv message", msg.Command())
-	}
-	return inv, nil
-}
-
-func (flow *handleRelayInvsFlow) requestBlock(requestHash *externalapi.DomainHash) (*externalapi.DomainBlock, bool, error) {
-	exists := flow.SharedRequestedBlocks().AddIfNotExists(requestHash)
-	if exists {
-		return nil, true, nil
-	}
-
-	// In case the function returns earlier than expected, we want to make sure flow.SharedRequestedBlocks() is
-	// clean from any pending blocks.
-	defer flow.SharedRequestedBlocks().Remove(requestHash)
-
-	getRelayBlocksMsg := appmessage.NewMsgRequestRelayBlocks([]*externalapi.DomainHash{requestHash})
-	err := flow.outgoingRoute.Enqueue(getRelayBlocksMsg)
-	if err != nil {
-		return nil, false, err
-	}
-
-	msgBlock, err := flow.readMsgBlock()
-	if err != nil {
-		return nil, false, err
-	}
-
-	block := appmessage.MsgBlockToDomainBlock(msgBlock)
-	blockHash := consensushashing.BlockHash(block)
-	if !blockHash.Equal(requestHash) {
-		return nil, false, protocolerrors.Errorf(true, "got unrequested block %s", blockHash)
-	}
-
-	return block, false, nil
-}
-
-// readMsgBlock returns the next msgBlock in msgChan, and populates invsQueue with any inv messages that meanwhile arrive.
-//
-// Note: this function assumes msgChan can contain only appmessage.MsgInvRelayBlock and appmessage.MsgBlock messages.
-func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock, err error) {
-	for {
-		message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-		if err != nil {
-			return nil, err
-		}
-
-		switch message := message.(type) {
-		case *appmessage.MsgInvRelayBlock:
-			flow.invsQueue = append(flow.invsQueue, message)
-		case *appmessage.MsgBlock:
-			return message, nil
-		default:
-			return nil, errors.Errorf("unexpected message %s", message.Command())
-		}
-	}
-}
-
-func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, *externalapi.VirtualChangeSet, error) {
-	blockHash := consensushashing.BlockHash(block)
-	virtualChangeSet, err := flow.Domain().Consensus().ValidateAndInsertBlock(block, true)
-	if err != nil {
-		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return nil, nil, errors.Wrapf(err, "failed to process block %s", blockHash)
-		}
-
-		missingParentsError := &ruleerrors.ErrMissingParents{}
-		if errors.As(err, missingParentsError) {
-			return missingParentsError.MissingParentHashes, nil, nil
-		}
-		// A duplicate block should not appear to the user as a warning and is already reported in the calling function
-		if !errors.Is(err, ruleerrors.ErrDuplicateBlock) {
-			log.Warnf("Rejected block %s from %s: %s", blockHash, flow.peer, err)
-		}
-		return nil, nil, protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
-	}
-	return nil, virtualChangeSet, nil
-}
-
-func (flow *handleRelayInvsFlow) relayBlock(block *externalapi.DomainBlock) error {
-	blockHash := consensushashing.BlockHash(block)
-	return flow.Broadcast(appmessage.NewMsgInvBlock(blockHash))
-}
-
-func (flow *handleRelayInvsFlow) processOrphan(block *externalapi.DomainBlock) error {
-	blockHash := consensushashing.BlockHash(block)
-
-	// Return if the block has been orphaned from elsewhere already
-	if flow.IsOrphan(blockHash) {
-		log.Debugf("Skipping orphan processing for block %s because it is already an orphan", blockHash)
-		return nil
-	}
-
-	// Add the block to the orphan set if it's within orphan resolution range
-	isBlockInOrphanResolutionRange, err := flow.isBlockInOrphanResolutionRange(blockHash)
-	if err != nil {
-		return err
-	}
-	if isBlockInOrphanResolutionRange {
-		if flow.Config().NetParams().DisallowDirectBlocksOnTopOfGenesis && !flow.Config().AllowSubmitBlockWhenNotSynced {
-			isGenesisVirtualSelectedParent, err := flow.isGenesisVirtualSelectedParent()
-			if err != nil {
-				return err
-			}
-
-			if isGenesisVirtualSelectedParent {
-				log.Infof("Cannot process orphan %s for a node with only the genesis block. The node needs to IBD "+
-					"to the recent pruning point before normal operation can resume.", blockHash)
-				return nil
-			}
-		}
-
-		log.Debugf("Block %s is within orphan resolution range. "+
-			"Adding it to the orphan set", blockHash)
-		flow.AddOrphan(block)
-		log.Debugf("Requesting block %s missing ancestors", blockHash)
-		return flow.AddOrphanRootsToQueue(blockHash)
-	}
-
-	// Start IBD unless we already are in IBD
-	log.Debugf("Block %s is out of orphan resolution range. "+
-		"Attempting to start IBD against it.", blockHash)
-
-	// Send the block to IBD flow via the IBDRequestChannel.
-	// Note that this is a non-blocking send, since if IBD is already running, there is no need to trigger it
-	select {
-	case flow.peer.IBDRequestChannel() <- block:
-	default:
-	}
-	return nil
-}
-
-func (flow *handleRelayInvsFlow) isGenesisVirtualSelectedParent() (bool, error) {
-	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
-	if err != nil {
-		return false, err
-	}
-
-	return virtualSelectedParent.Equal(flow.Config().NetParams().GenesisHash), nil
-}
-
-func (flow *handleRelayInvsFlow) isChildOfGenesis(block *externalapi.DomainBlock) bool {
-	parents := block.Header.DirectParents()
-	return len(parents) == 1 && parents[0].Equal(flow.Config().NetParams().GenesisHash)
-}
-
-// isBlockInOrphanResolutionRange finds out whether the given blockHash should be
-// retrieved via the unorphaning mechanism or via IBD. This method sends a
-// getBlockLocator request to the peer with a limit of orphanResolutionRange.
-// In the response, if we know none of the hashes, we should retrieve the given
-// blockHash via IBD. Otherwise, via unorphaning.
-func (flow *handleRelayInvsFlow) isBlockInOrphanResolutionRange(blockHash *externalapi.DomainHash) (bool, error) {
-	err := flow.sendGetBlockLocator(blockHash, orphanResolutionRange)
-	if err != nil {
-		return false, err
-	}
-
-	blockLocatorHashes, err := flow.receiveBlockLocator()
-	if err != nil {
-		return false, err
-	}
-	for _, blockLocatorHash := range blockLocatorHashes {
-		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(blockLocatorHash)
-		if err != nil {
-			return false, err
-		}
-		if blockInfo.Exists && blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
-			return true, nil
-		}
-	}
-	return false, nil
-}
-
-func (flow *handleRelayInvsFlow) AddOrphanRootsToQueue(orphan *externalapi.DomainHash) error {
-	orphanRoots, orphanExists, err := flow.GetOrphanRoots(orphan)
-	if err != nil {
-		return err
-	}
-
-	if !orphanExists {
-		log.Infof("Orphan block %s was missing from the orphan pool while requesting for its roots. This "+
-			"probably happened because it was randomly evicted immediately after it was added.", orphan)
-	}
-
-	if len(orphanRoots) == 0 {
-		// In some rare cases we get here when there are no orphan roots already
-		return nil
-	}
-	log.Infof("Block %s has %d missing ancestors. Adding them to the invs queue...", orphan, len(orphanRoots))
-
-	invMessages := make([]*appmessage.MsgInvRelayBlock, len(orphanRoots))
-	for i, root := range orphanRoots {
-		log.Debugf("Adding block %s missing ancestor %s to the invs queue", orphan, root)
-		invMessages[i] = appmessage.NewMsgInvBlock(root)
-	}
-
-	flow.invsQueue = append(invMessages, flow.invsQueue...)
-	return nil
-}

app/protocol/flows/v4/blockrelay/handle_request_block_locator.go

@@ -1,75 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// RequestBlockLocatorContext is the interface for the context needed for the HandleRequestBlockLocator flow.
-type RequestBlockLocatorContext interface {
-	Domain() domain.Domain
-}
-
-type handleRequestBlockLocatorFlow struct {
-	RequestBlockLocatorContext
-	incomingRoute, outgoingRoute *router.Route
-}
-
-// HandleRequestBlockLocator handles getBlockLocator messages
-func HandleRequestBlockLocator(context RequestBlockLocatorContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route) error {
-
-	flow := &handleRequestBlockLocatorFlow{
-		RequestBlockLocatorContext: context,
-		incomingRoute:              incomingRoute,
-		outgoingRoute:              outgoingRoute,
-	}
-	return flow.start()
-}
-
-func (flow *handleRequestBlockLocatorFlow) start() error {
-	for {
-		highHash, limit, err := flow.receiveGetBlockLocator()
-		if err != nil {
-			return err
-		}
-		log.Debugf("Received getBlockLocator with highHash: %s, limit: %d", highHash, limit)
-
-		locator, err := flow.Domain().Consensus().CreateBlockLocatorFromPruningPoint(highHash, limit)
-		if err != nil || len(locator) == 0 {
-			if err != nil {
-				log.Debugf("Received error from CreateBlockLocatorFromPruningPoint: %s", err)
-			}
-			return protocolerrors.Errorf(true, "couldn't build a block "+
-				"locator between the pruning point and %s", highHash)
-		}
-
-		err = flow.sendBlockLocator(locator)
-		if err != nil {
-			return err
-		}
-	}
-}
-
-func (flow *handleRequestBlockLocatorFlow) receiveGetBlockLocator() (highHash *externalapi.DomainHash, limit uint32, err error) {
-
-	message, err := flow.incomingRoute.Dequeue()
-	if err != nil {
-		return nil, 0, err
-	}
-	msgGetBlockLocator := message.(*appmessage.MsgRequestBlockLocator)
-
-	return msgGetBlockLocator.HighHash, msgGetBlockLocator.Limit, nil
-}
-
-func (flow *handleRequestBlockLocatorFlow) sendBlockLocator(locator externalapi.BlockLocator) error {
-	msgBlockLocator := appmessage.NewMsgBlockLocator(locator)
-	err := flow.outgoingRoute.Enqueue(msgBlockLocator)
-	if err != nil {
-		return err
-	}
-	return nil
-}

app/protocol/flows/v4/blockrelay/handle_request_headers.go

@@ -1,107 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// This constant must be equal at both syncer and syncee. Therefore, never (!!) change this constant unless a new p2p
-// version is introduced. See `TestIBDBatchSizeLessThanRouteCapacity` as well.
-const ibdBatchSize = 100
-
-// RequestHeadersContext is the interface for the context needed for the HandleRequestHeaders flow.
-type RequestHeadersContext interface {
-	Domain() domain.Domain
-}
-
-type handleRequestHeadersFlow struct {
-	RequestHeadersContext
-	incomingRoute, outgoingRoute *router.Route
-	peer                         *peer.Peer
-}
-
-// HandleRequestHeaders handles RequestHeaders messages
-func HandleRequestHeaders(context RequestHeadersContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route, peer *peer.Peer) error {
-
-	flow := &handleRequestHeadersFlow{
-		RequestHeadersContext: context,
-		incomingRoute:         incomingRoute,
-		outgoingRoute:         outgoingRoute,
-		peer:                  peer,
-	}
-	return flow.start()
-}
-
-func (flow *handleRequestHeadersFlow) start() error {
-	for {
-		lowHash, highHash, err := receiveRequestHeaders(flow.incomingRoute)
-		if err != nil {
-			return err
-		}
-		log.Debugf("Recieved requestHeaders with lowHash: %s, highHash: %s", lowHash, highHash)
-
-		for !lowHash.Equal(highHash) {
-			log.Debugf("Getting block headers between %s and %s to %s", lowHash, highHash, flow.peer)
-
-			// GetHashesBetween is a relatively heavy operation so we limit it
-			// in order to avoid locking the consensus for too long
-			// maxBlocks MUST be >= MergeSetSizeLimit + 1
-			const maxBlocks = 1 << 10
-			blockHashes, _, err := flow.Domain().Consensus().GetHashesBetween(lowHash, highHash, maxBlocks)
-			if err != nil {
-				return err
-			}
-			log.Debugf("Got %d header hashes above lowHash %s", len(blockHashes), lowHash)
-
-			blockHeaders := make([]*appmessage.MsgBlockHeader, len(blockHashes))
-			for i, blockHash := range blockHashes {
-				blockHeader, err := flow.Domain().Consensus().GetBlockHeader(blockHash)
-				if err != nil {
-					return err
-				}
-				blockHeaders[i] = appmessage.DomainBlockHeaderToBlockHeader(blockHeader)
-			}
-
-			blockHeadersMessage := appmessage.NewBlockHeadersMessage(blockHeaders)
-			err = flow.outgoingRoute.Enqueue(blockHeadersMessage)
-			if err != nil {
-				return err
-			}
-
-			message, err := flow.incomingRoute.Dequeue()
-			if err != nil {
-				return err
-			}
-			if _, ok := message.(*appmessage.MsgRequestNextHeaders); !ok {
-				return protocolerrors.Errorf(true, "received unexpected message type. "+
-					"expected: %s, got: %s", appmessage.CmdRequestNextHeaders, message.Command())
-			}
-
-			// The next lowHash is the last element in blockHashes
-			lowHash = blockHashes[len(blockHashes)-1]
-		}
-
-		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgDoneHeaders())
-		if err != nil {
-			return err
-		}
-	}
-}
-
-func receiveRequestHeaders(incomingRoute *router.Route) (lowHash *externalapi.DomainHash,
-	highHash *externalapi.DomainHash, err error) {
-
-	message, err := incomingRoute.Dequeue()
-	if err != nil {
-		return nil, nil, err
-	}
-	msgRequestIBDBlocks := message.(*appmessage.MsgRequestHeaders)
-
-	return msgRequestIBDBlocks.LowHash, msgRequestIBDBlocks.HighHash, nil
-}

app/protocol/flows/v4/blockrelay/handle_request_pruning_point_utxo_set.go

@@ -1,140 +0,0 @@
-package blockrelay
-
-import (
-	"errors"
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/kaspanet/kaspad/infrastructure/logger"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleRequestPruningPointUTXOSetContext is the interface for the context needed for the HandleRequestPruningPointUTXOSet flow.
-type HandleRequestPruningPointUTXOSetContext interface {
-	Domain() domain.Domain
-}
-
-type handleRequestPruningPointUTXOSetFlow struct {
-	HandleRequestPruningPointUTXOSetContext
-	incomingRoute, outgoingRoute *router.Route
-}
-
-// HandleRequestPruningPointUTXOSet listens to appmessage.MsgRequestPruningPointUTXOSet messages and sends
-// the pruning point UTXO set and block body.
-func HandleRequestPruningPointUTXOSet(context HandleRequestPruningPointUTXOSetContext, incomingRoute,
-	outgoingRoute *router.Route) error {
-
-	flow := &handleRequestPruningPointUTXOSetFlow{
-		HandleRequestPruningPointUTXOSetContext: context,
-		incomingRoute:                           incomingRoute,
-		outgoingRoute:                           outgoingRoute,
-	}
-
-	return flow.start()
-}
-
-func (flow *handleRequestPruningPointUTXOSetFlow) start() error {
-	for {
-		msgRequestPruningPointUTXOSet, err := flow.waitForRequestPruningPointUTXOSetMessages()
-		if err != nil {
-			return err
-		}
-
-		err = flow.handleRequestPruningPointUTXOSetMessage(msgRequestPruningPointUTXOSet)
-		if err != nil {
-			return err
-		}
-	}
-}
-
-func (flow *handleRequestPruningPointUTXOSetFlow) handleRequestPruningPointUTXOSetMessage(
-	msgRequestPruningPointUTXOSet *appmessage.MsgRequestPruningPointUTXOSet) error {
-
-	onEnd := logger.LogAndMeasureExecutionTime(log, "handleRequestPruningPointUTXOSetFlow")
-	defer onEnd()
-
-	log.Debugf("Got request for pruning point UTXO set")
-
-	return flow.sendPruningPointUTXOSet(msgRequestPruningPointUTXOSet)
-}
-
-func (flow *handleRequestPruningPointUTXOSetFlow) waitForRequestPruningPointUTXOSetMessages() (
-	*appmessage.MsgRequestPruningPointUTXOSet, error) {
-
-	message, err := flow.incomingRoute.Dequeue()
-	if err != nil {
-		return nil, err
-	}
-	msgRequestPruningPointUTXOSet, ok := message.(*appmessage.MsgRequestPruningPointUTXOSet)
-	if !ok {
-		// TODO: Change to shouldBan: true once we fix the bug of getting redundant messages
-		return nil, protocolerrors.Errorf(false, "received unexpected message type. "+
-			"expected: %s, got: %s", appmessage.CmdRequestPruningPointUTXOSet, message.Command())
-	}
-	return msgRequestPruningPointUTXOSet, nil
-}
-
-func (flow *handleRequestPruningPointUTXOSetFlow) sendPruningPointUTXOSet(
-	msgRequestPruningPointUTXOSet *appmessage.MsgRequestPruningPointUTXOSet) error {
-
-	// Send the UTXO set in `step`-sized chunks
-	const step = 1000
-	var fromOutpoint *externalapi.DomainOutpoint
-	chunksSent := 0
-	for {
-		pruningPointUTXOs, err := flow.Domain().Consensus().GetPruningPointUTXOs(
-			msgRequestPruningPointUTXOSet.PruningPointHash, fromOutpoint, step)
-		if err != nil {
-			if errors.Is(err, ruleerrors.ErrWrongPruningPointHash) {
-				return flow.outgoingRoute.Enqueue(appmessage.NewMsgUnexpectedPruningPoint())
-			}
-		}
-
-		log.Debugf("Retrieved %d UTXOs for pruning block %s",
-			len(pruningPointUTXOs), msgRequestPruningPointUTXOSet.PruningPointHash)
-
-		outpointAndUTXOEntryPairs :=
-			appmessage.DomainOutpointAndUTXOEntryPairsToOutpointAndUTXOEntryPairs(pruningPointUTXOs)
-		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgPruningPointUTXOSetChunk(outpointAndUTXOEntryPairs))
-		if err != nil {
-			return err
-		}
-
-		finished := len(pruningPointUTXOs) < step
-		if finished && chunksSent%ibdBatchSize != 0 {
-			log.Debugf("Finished sending UTXOs for pruning block %s",
-				msgRequestPruningPointUTXOSet.PruningPointHash)
-
-			return flow.outgoingRoute.Enqueue(appmessage.NewMsgDonePruningPointUTXOSetChunks())
-		}
-
-		if len(pruningPointUTXOs) > 0 {
-			fromOutpoint = pruningPointUTXOs[len(pruningPointUTXOs)-1].Outpoint
-		}
-		chunksSent++
-
-		// Wait for the peer to request more chunks every `ibdBatchSize` chunks
-		if chunksSent%ibdBatchSize == 0 {
-			message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-			if err != nil {
-				return err
-			}
-			_, ok := message.(*appmessage.MsgRequestNextPruningPointUTXOSetChunk)
-			if !ok {
-				// TODO: Change to shouldBan: true once we fix the bug of getting redundant messages
-				return protocolerrors.Errorf(false, "received unexpected message type. "+
-					"expected: %s, got: %s", appmessage.CmdRequestNextPruningPointUTXOSetChunk, message.Command())
-			}
-
-			if finished {
-				log.Debugf("Finished sending UTXOs for pruning block %s",
-					msgRequestPruningPointUTXOSet.PruningPointHash)
-
-				return flow.outgoingRoute.Enqueue(appmessage.NewMsgDonePruningPointUTXOSetChunks())
-			}
-		}
-	}
-}

app/protocol/flows/v4/blockrelay/ibd.go

@@ -1,650 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model"
-	"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/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/logger"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util/difficulty"
-	"github.com/pkg/errors"
-	"math/big"
-	"time"
-)
-
-// IBDContext is the interface for the context needed for the HandleIBD flow.
-type IBDContext interface {
-	Domain() domain.Domain
-	Config() *config.Config
-	OnNewBlock(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error
-	OnVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error
-	OnNewBlockTemplate() error
-	OnPruningPointUTXOSetOverride() error
-	IsIBDRunning() bool
-	TrySetIBDRunning(ibdPeer *peerpkg.Peer) bool
-	UnsetIBDRunning()
-	IsRecoverableError(err error) bool
-}
-
-type handleIBDFlow struct {
-	IBDContext
-	incomingRoute, outgoingRoute *router.Route
-	peer                         *peerpkg.Peer
-}
-
-// HandleIBD handles IBD
-func HandleIBD(context IBDContext, incomingRoute *router.Route, outgoingRoute *router.Route,
-	peer *peerpkg.Peer) error {
-
-	flow := &handleIBDFlow{
-		IBDContext:    context,
-		incomingRoute: incomingRoute,
-		outgoingRoute: outgoingRoute,
-		peer:          peer,
-	}
-	return flow.start()
-}
-
-func (flow *handleIBDFlow) start() error {
-	for {
-		// Wait for IBD requests triggered by other flows
-		block, ok := <-flow.peer.IBDRequestChannel()
-		if !ok {
-			return nil
-		}
-		err := flow.runIBDIfNotRunning(block)
-		if err != nil {
-			return err
-		}
-	}
-}
-
-func (flow *handleIBDFlow) runIBDIfNotRunning(block *externalapi.DomainBlock) error {
-	highHash := consensushashing.BlockHash(block)
-
-	// Temp code to avoid IBD from lagging nodes publishing their side-chain. This patch
-	// is applied only to p2p v4 since the implemented IBD negotiation has quadratic complexity in this worst-case.
-	// See IBD logic of p2p v5 for further details.
-	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
-	if err == nil {
-		virtualSelectedParentHeader, err := flow.Domain().Consensus().GetBlockHeader(virtualSelectedParent)
-		if err == nil {
-			// We first check that DAA score of the relay block is at distance of more than DAA window size.
-			// This indicates a side-chain which is not in the future of any block in the current virtual DAA window.
-			if virtualSelectedParentHeader.DAAScore() > block.Header.DAAScore()+2641 {
-				// We then find the 'unit' of current virtual difficulty. We check if the relay block is at least
-				// at distance of 180 such units. This signals another condition for a pow-weak side-chain.
-				virtualDifficulty := difficulty.CalcWork(virtualSelectedParentHeader.Bits())
-				var virtualSub, difficultyMul big.Int
-				if difficultyMul.Mul(virtualDifficulty, big.NewInt(180)).
-					Cmp(virtualSub.Sub(virtualSelectedParentHeader.BlueWork(), block.Header.BlueWork())) < 0 {
-					log.Criticalf("Avoiding IBD triggered by relay %s with %d DAA score diff and lower blue work (%d, %d)",
-						highHash,
-						virtualSelectedParentHeader.DAAScore()-block.Header.DAAScore(),
-						virtualSelectedParentHeader.BlueWork(), block.Header.BlueWork())
-					return nil
-				}
-			}
-		}
-	}
-
-	wasIBDNotRunning := flow.TrySetIBDRunning(flow.peer)
-	if !wasIBDNotRunning {
-		log.Debugf("IBD is already running")
-		return nil
-	}
-
-	isFinishedSuccessfully := false
-	defer func() {
-		flow.UnsetIBDRunning()
-		flow.logIBDFinished(isFinishedSuccessfully)
-	}()
-
-	log.Infof("IBD started with peer %s and highHash %s", flow.peer, highHash)
-	log.Infof("Syncing blocks up to %s", highHash)
-	log.Infof("Trying to find highest shared chain block with peer %s with high hash %s", flow.peer, highHash)
-	highestSharedBlockHash, highestSharedBlockFound, err := flow.findHighestSharedBlockHash(highHash)
-	if err != nil {
-		return err
-	}
-	log.Infof("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
-
-	shouldDownloadHeadersProof, shouldSync, err := flow.shouldSyncAndShouldDownloadHeadersProof(block, highestSharedBlockFound)
-	if err != nil {
-		return err
-	}
-
-	if !shouldSync {
-		return nil
-	}
-
-	if shouldDownloadHeadersProof {
-		log.Infof("Starting IBD with headers proof")
-		err := flow.ibdWithHeadersProof(highHash, block.Header.DAAScore())
-		if err != nil {
-			return err
-		}
-	} else {
-		if flow.Config().NetParams().DisallowDirectBlocksOnTopOfGenesis && !flow.Config().AllowSubmitBlockWhenNotSynced {
-			isGenesisVirtualSelectedParent, err := flow.isGenesisVirtualSelectedParent()
-			if err != nil {
-				return err
-			}
-
-			if isGenesisVirtualSelectedParent {
-				log.Infof("Cannot IBD to %s because it won't change the pruning point. The node needs to IBD "+
-					"to the recent pruning point before normal operation can resume.", highHash)
-				return nil
-			}
-		}
-
-		err = flow.syncPruningPointFutureHeaders(flow.Domain().Consensus(), highestSharedBlockHash, highHash, block.Header.DAAScore())
-		if err != nil {
-			return err
-		}
-	}
-
-	err = flow.syncMissingBlockBodies(highHash)
-	if err != nil {
-		return err
-	}
-
-	log.Debugf("Finished syncing blocks up to %s", highHash)
-	isFinishedSuccessfully = true
-	return nil
-}
-
-func (flow *handleIBDFlow) isGenesisVirtualSelectedParent() (bool, error) {
-	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
-	if err != nil {
-		return false, err
-	}
-
-	return virtualSelectedParent.Equal(flow.Config().NetParams().GenesisHash), nil
-}
-
-func (flow *handleIBDFlow) logIBDFinished(isFinishedSuccessfully bool) {
-	successString := "successfully"
-	if !isFinishedSuccessfully {
-		successString = "(interrupted)"
-	}
-	log.Infof("IBD finished %s", successString)
-}
-
-// findHighestSharedBlock attempts to find the highest shared block between the peer
-// and this node. This method may fail because the peer and us have conflicting pruning
-// points. In that case we return (nil, false, nil) so that we may stop IBD gracefully.
-func (flow *handleIBDFlow) findHighestSharedBlockHash(
-	targetHash *externalapi.DomainHash) (*externalapi.DomainHash, bool, error) {
-
-	log.Debugf("Sending a blockLocator to %s between pruning point and headers selected tip", flow.peer)
-	blockLocator, err := flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
-	if err != nil {
-		return nil, false, err
-	}
-
-	for {
-		highestHash, highestHashFound, err := flow.fetchHighestHash(targetHash, blockLocator)
-		if err != nil {
-			return nil, false, err
-		}
-		if !highestHashFound {
-			return nil, false, nil
-		}
-		highestHashIndex, err := flow.findHighestHashIndex(highestHash, blockLocator)
-		if err != nil {
-			return nil, false, err
-		}
-
-		if highestHashIndex == 0 ||
-			// If the block locator contains only two adjacent chain blocks, the
-			// syncer will always find the same highest chain block, so to avoid
-			// an endless loop, we explicitly stop the loop in such situation.
-			(len(blockLocator) == 2 && highestHashIndex == 1) {
-
-			return highestHash, true, nil
-		}
-
-		locatorHashAboveHighestHash := highestHash
-		if highestHashIndex > 0 {
-			locatorHashAboveHighestHash = blockLocator[highestHashIndex-1]
-		}
-
-		blockLocator, err = flow.nextBlockLocator(highestHash, locatorHashAboveHighestHash)
-		if err != nil {
-			return nil, false, err
-		}
-	}
-}
-
-func (flow *handleIBDFlow) nextBlockLocator(lowHash, highHash *externalapi.DomainHash) (externalapi.BlockLocator, error) {
-	log.Debugf("Sending a blockLocator to %s between %s and %s", flow.peer, lowHash, highHash)
-	blockLocator, err := flow.Domain().Consensus().CreateHeadersSelectedChainBlockLocator(lowHash, highHash)
-	if err != nil {
-		if errors.Is(model.ErrBlockNotInSelectedParentChain, err) {
-			return nil, err
-		}
-		log.Debugf("Headers selected parent chain moved since findHighestSharedBlockHash - " +
-			"restarting with full block locator")
-		blockLocator, err = flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return blockLocator, nil
-}
-
-func (flow *handleIBDFlow) findHighestHashIndex(
-	highestHash *externalapi.DomainHash, blockLocator externalapi.BlockLocator) (int, error) {
-
-	highestHashIndex := 0
-	highestHashIndexFound := false
-	for i, blockLocatorHash := range blockLocator {
-		if highestHash.Equal(blockLocatorHash) {
-			highestHashIndex = i
-			highestHashIndexFound = true
-			break
-		}
-	}
-	if !highestHashIndexFound {
-		return 0, protocolerrors.Errorf(true, "highest hash %s "+
-			"returned from peer %s is not in the original blockLocator", highestHash, flow.peer)
-	}
-	log.Debugf("The index of the highest hash in the original "+
-		"blockLocator sent to %s is %d", flow.peer, highestHashIndex)
-
-	return highestHashIndex, nil
-}
-
-// fetchHighestHash attempts to fetch the highest hash the peer knows amongst the given
-// blockLocator. This method may fail because the peer and us have conflicting pruning
-// points. In that case we return (nil, false, nil) so that we may stop IBD gracefully.
-func (flow *handleIBDFlow) fetchHighestHash(
-	targetHash *externalapi.DomainHash, blockLocator externalapi.BlockLocator) (*externalapi.DomainHash, bool, error) {
-
-	ibdBlockLocatorMessage := appmessage.NewMsgIBDBlockLocator(targetHash, blockLocator)
-	err := flow.outgoingRoute.Enqueue(ibdBlockLocatorMessage)
-	if err != nil {
-		return nil, false, err
-	}
-	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-	if err != nil {
-		return nil, false, err
-	}
-	switch message := message.(type) {
-	case *appmessage.MsgIBDBlockLocatorHighestHash:
-		highestHash := message.HighestHash
-		log.Debugf("The highest hash the peer %s knows is %s", flow.peer, highestHash)
-
-		return highestHash, true, nil
-	case *appmessage.MsgIBDBlockLocatorHighestHashNotFound:
-		log.Debugf("Peer %s does not know any block within our blockLocator. "+
-			"This should only happen if there's a DAG split deeper than the pruning point.", flow.peer)
-		return nil, false, nil
-	default:
-		return nil, false, protocolerrors.Errorf(true, "received unexpected message type. "+
-			"expected: %s, got: %s", appmessage.CmdIBDBlockLocatorHighestHash, message.Command())
-	}
-}
-
-func (flow *handleIBDFlow) syncPruningPointFutureHeaders(consensus externalapi.Consensus, highestSharedBlockHash *externalapi.DomainHash,
-	highHash *externalapi.DomainHash, highBlockDAAScore uint64) error {
-
-	log.Infof("Downloading headers from %s", flow.peer)
-
-	err := flow.sendRequestHeaders(highestSharedBlockHash, highHash)
-	if err != nil {
-		return err
-	}
-
-	highestSharedBlockHeader, err := consensus.GetBlockHeader(highestSharedBlockHash)
-	if err != nil {
-		return err
-	}
-	progressReporter := newIBDProgressReporter(highestSharedBlockHeader.DAAScore(), highBlockDAAScore, "block headers")
-
-	// Keep a short queue of BlockHeadersMessages so that there's
-	// never a moment when the node is not validating and inserting
-	// headers
-	blockHeadersMessageChan := make(chan *appmessage.BlockHeadersMessage, 2)
-	errChan := make(chan error)
-	spawn("handleRelayInvsFlow-syncPruningPointFutureHeaders", func() {
-		for {
-			blockHeadersMessage, doneIBD, err := flow.receiveHeaders()
-			if err != nil {
-				errChan <- err
-				return
-			}
-			if doneIBD {
-				close(blockHeadersMessageChan)
-				return
-			}
-
-			blockHeadersMessageChan <- blockHeadersMessage
-
-			err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestNextHeaders())
-			if err != nil {
-				errChan <- err
-				return
-			}
-		}
-	})
-
-	for {
-		select {
-		case ibdBlocksMessage, ok := <-blockHeadersMessageChan:
-			if !ok {
-				// If the highHash has not been received, the peer is misbehaving
-				highHashBlockInfo, err := consensus.GetBlockInfo(highHash)
-				if err != nil {
-					return err
-				}
-				if !highHashBlockInfo.Exists {
-					return protocolerrors.Errorf(true, "did not receive "+
-						"highHash block %s from peer %s during block download", highHash, flow.peer)
-				}
-				return nil
-			}
-			for _, header := range ibdBlocksMessage.BlockHeaders {
-				err = flow.processHeader(consensus, header)
-				if err != nil {
-					return err
-				}
-			}
-
-			lastReceivedHeader := ibdBlocksMessage.BlockHeaders[len(ibdBlocksMessage.BlockHeaders)-1]
-			progressReporter.reportProgress(len(ibdBlocksMessage.BlockHeaders), lastReceivedHeader.DAAScore)
-		case err := <-errChan:
-			return err
-		}
-	}
-}
-
-func (flow *handleIBDFlow) sendRequestHeaders(highestSharedBlockHash *externalapi.DomainHash,
-	peerSelectedTipHash *externalapi.DomainHash) error {
-
-	msgGetBlockInvs := appmessage.NewMsgRequstHeaders(highestSharedBlockHash, peerSelectedTipHash)
-	return flow.outgoingRoute.Enqueue(msgGetBlockInvs)
-}
-
-func (flow *handleIBDFlow) receiveHeaders() (msgIBDBlock *appmessage.BlockHeadersMessage, doneHeaders bool, err error) {
-	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-	if err != nil {
-		return nil, false, err
-	}
-	switch message := message.(type) {
-	case *appmessage.BlockHeadersMessage:
-		return message, false, nil
-	case *appmessage.MsgDoneHeaders:
-		return nil, true, nil
-	default:
-		return nil, false,
-			protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s or %s, got: %s",
-				appmessage.CmdBlockHeaders,
-				appmessage.CmdDoneHeaders,
-				message.Command())
-	}
-}
-
-func (flow *handleIBDFlow) processHeader(consensus externalapi.Consensus, msgBlockHeader *appmessage.MsgBlockHeader) error {
-	header := appmessage.BlockHeaderToDomainBlockHeader(msgBlockHeader)
-	block := &externalapi.DomainBlock{
-		Header:       header,
-		Transactions: nil,
-	}
-
-	blockHash := consensushashing.BlockHash(block)
-	blockInfo, err := consensus.GetBlockInfo(blockHash)
-	if err != nil {
-		return err
-	}
-	if blockInfo.Exists {
-		log.Debugf("Block header %s is already in the DAG. Skipping...", blockHash)
-		return nil
-	}
-	_, err = consensus.ValidateAndInsertBlock(block, false)
-	if err != nil {
-		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return errors.Wrapf(err, "failed to process header %s during IBD", blockHash)
-		}
-
-		if errors.Is(err, ruleerrors.ErrDuplicateBlock) {
-			log.Debugf("Skipping block header %s as it is a duplicate", blockHash)
-		} else {
-			log.Infof("Rejected block header %s from %s during IBD: %s", blockHash, flow.peer, err)
-			return protocolerrors.Wrapf(true, err, "got invalid block header %s during IBD", blockHash)
-		}
-	}
-
-	return nil
-}
-
-func (flow *handleIBDFlow) validatePruningPointFutureHeaderTimestamps() error {
-	headerSelectedTipHash, err := flow.Domain().StagingConsensus().GetHeadersSelectedTip()
-	if err != nil {
-		return err
-	}
-	headerSelectedTipHeader, err := flow.Domain().StagingConsensus().GetBlockHeader(headerSelectedTipHash)
-	if err != nil {
-		return err
-	}
-	headerSelectedTipTimestamp := headerSelectedTipHeader.TimeInMilliseconds()
-
-	currentSelectedTipHash, err := flow.Domain().Consensus().GetHeadersSelectedTip()
-	if err != nil {
-		return err
-	}
-	currentSelectedTipHeader, err := flow.Domain().Consensus().GetBlockHeader(currentSelectedTipHash)
-	if err != nil {
-		return err
-	}
-	currentSelectedTipTimestamp := currentSelectedTipHeader.TimeInMilliseconds()
-
-	if headerSelectedTipTimestamp < currentSelectedTipTimestamp {
-		return protocolerrors.Errorf(false, "the timestamp of the candidate selected "+
-			"tip is smaller than the current selected tip")
-	}
-
-	minTimestampDifferenceInMilliseconds := (10 * time.Minute).Milliseconds()
-	if headerSelectedTipTimestamp-currentSelectedTipTimestamp < minTimestampDifferenceInMilliseconds {
-		return protocolerrors.Errorf(false, "difference between the timestamps of "+
-			"the current pruning point and the candidate pruning point is too small. Aborting IBD...")
-	}
-	return nil
-}
-
-func (flow *handleIBDFlow) receiveAndInsertPruningPointUTXOSet(
-	consensus externalapi.Consensus, pruningPointHash *externalapi.DomainHash) (bool, error) {
-
-	onEnd := logger.LogAndMeasureExecutionTime(log, "receiveAndInsertPruningPointUTXOSet")
-	defer onEnd()
-
-	receivedChunkCount := 0
-	receivedUTXOCount := 0
-	for {
-		message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-		if err != nil {
-			return false, err
-		}
-
-		switch message := message.(type) {
-		case *appmessage.MsgPruningPointUTXOSetChunk:
-			receivedUTXOCount += len(message.OutpointAndUTXOEntryPairs)
-			domainOutpointAndUTXOEntryPairs :=
-				appmessage.OutpointAndUTXOEntryPairsToDomainOutpointAndUTXOEntryPairs(message.OutpointAndUTXOEntryPairs)
-
-			err := consensus.AppendImportedPruningPointUTXOs(domainOutpointAndUTXOEntryPairs)
-			if err != nil {
-				return false, err
-			}
-
-			receivedChunkCount++
-			if receivedChunkCount%ibdBatchSize == 0 {
-				log.Debugf("Received %d UTXO set chunks so far, totaling in %d UTXOs",
-					receivedChunkCount, receivedUTXOCount)
-
-				requestNextPruningPointUTXOSetChunkMessage := appmessage.NewMsgRequestNextPruningPointUTXOSetChunk()
-				err := flow.outgoingRoute.Enqueue(requestNextPruningPointUTXOSetChunkMessage)
-				if err != nil {
-					return false, err
-				}
-			}
-
-		case *appmessage.MsgDonePruningPointUTXOSetChunks:
-			log.Infof("Finished receiving the UTXO set. Total UTXOs: %d", receivedUTXOCount)
-			return true, nil
-
-		case *appmessage.MsgUnexpectedPruningPoint:
-			log.Infof("Could not receive the next UTXO chunk because the pruning point %s "+
-				"is no longer the pruning point of peer %s", pruningPointHash, flow.peer)
-			return false, nil
-
-		default:
-			return false, protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s or %s or %s, got: %s", appmessage.CmdPruningPointUTXOSetChunk,
-				appmessage.CmdDonePruningPointUTXOSetChunks, appmessage.CmdUnexpectedPruningPoint, message.Command(),
-			)
-		}
-	}
-}
-
-func (flow *handleIBDFlow) syncMissingBlockBodies(highHash *externalapi.DomainHash) error {
-	hashes, err := flow.Domain().Consensus().GetMissingBlockBodyHashes(highHash)
-	if err != nil {
-		return err
-	}
-	if len(hashes) == 0 {
-		// Blocks can be inserted inside the DAG during IBD if those were requested before IBD started.
-		// In rare cases, all the IBD blocks might be already inserted by the time we reach this point.
-		// In these cases - GetMissingBlockBodyHashes would return an empty array.
-		log.Debugf("No missing block body hashes found.")
-		return nil
-	}
-
-	lowBlockHeader, err := flow.Domain().Consensus().GetBlockHeader(hashes[0])
-	if err != nil {
-		return err
-	}
-	highBlockHeader, err := flow.Domain().Consensus().GetBlockHeader(hashes[len(hashes)-1])
-	if err != nil {
-		return err
-	}
-	progressReporter := newIBDProgressReporter(lowBlockHeader.DAAScore(), highBlockHeader.DAAScore(), "blocks")
-	highestProcessedDAAScore := lowBlockHeader.DAAScore()
-
-	for offset := 0; offset < len(hashes); offset += ibdBatchSize {
-		var hashesToRequest []*externalapi.DomainHash
-		if offset+ibdBatchSize < len(hashes) {
-			hashesToRequest = hashes[offset : offset+ibdBatchSize]
-		} else {
-			hashesToRequest = hashes[offset:]
-		}
-
-		err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDBlocks(hashesToRequest))
-		if err != nil {
-			return err
-		}
-
-		for _, expectedHash := range hashesToRequest {
-			message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-			if err != nil {
-				return err
-			}
-
-			msgIBDBlock, ok := message.(*appmessage.MsgIBDBlock)
-			if !ok {
-				return protocolerrors.Errorf(true, "received unexpected message type. "+
-					"expected: %s, got: %s", appmessage.CmdIBDBlock, message.Command())
-			}
-
-			block := appmessage.MsgBlockToDomainBlock(msgIBDBlock.MsgBlock)
-			blockHash := consensushashing.BlockHash(block)
-			if !expectedHash.Equal(blockHash) {
-				return protocolerrors.Errorf(true, "expected block %s but got %s", expectedHash, blockHash)
-			}
-
-			err = flow.banIfBlockIsHeaderOnly(block)
-			if err != nil {
-				return err
-			}
-
-			virtualChangeSet, err := flow.Domain().Consensus().ValidateAndInsertBlock(block, false)
-			if err != nil {
-				if errors.Is(err, ruleerrors.ErrDuplicateBlock) {
-					log.Debugf("Skipping IBD Block %s as it has already been added to the DAG", blockHash)
-					continue
-				}
-				return protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "invalid block %s", blockHash)
-			}
-			err = flow.OnNewBlock(block, virtualChangeSet)
-			if err != nil {
-				return err
-			}
-
-			highestProcessedDAAScore = block.Header.DAAScore()
-		}
-
-		progressReporter.reportProgress(len(hashesToRequest), highestProcessedDAAScore)
-	}
-
-	return flow.resolveVirtual(highestProcessedDAAScore)
-}
-
-func (flow *handleIBDFlow) banIfBlockIsHeaderOnly(block *externalapi.DomainBlock) error {
-	if len(block.Transactions) == 0 {
-		return protocolerrors.Errorf(true, "sent header of %s block where expected block with body",
-			consensushashing.BlockHash(block))
-	}
-
-	return nil
-}
-
-func (flow *handleIBDFlow) resolveVirtual(estimatedVirtualDAAScoreTarget uint64) error {
-	virtualDAAScoreStart, err := flow.Domain().Consensus().GetVirtualDAAScore()
-	if err != nil {
-		return err
-	}
-
-	for i := 0; ; i++ {
-		if i%10 == 0 {
-			virtualDAAScore, err := flow.Domain().Consensus().GetVirtualDAAScore()
-			if err != nil {
-				return err
-			}
-			var percents int
-			if estimatedVirtualDAAScoreTarget-virtualDAAScoreStart <= 0 {
-				percents = 100
-			} else {
-				percents = int(float64(virtualDAAScore-virtualDAAScoreStart) / float64(estimatedVirtualDAAScoreTarget-virtualDAAScoreStart) * 100)
-			}
-			log.Infof("Resolving virtual. Estimated progress: %d%%", percents)
-		}
-		virtualChangeSet, isCompletelyResolved, err := flow.Domain().Consensus().ResolveVirtual()
-		if err != nil {
-			return err
-		}
-
-		err = flow.OnVirtualChange(virtualChangeSet)
-		if err != nil {
-			return err
-		}
-
-		if isCompletelyResolved {
-			log.Infof("Resolved virtual")
-			err = flow.OnNewBlockTemplate()
-			if err != nil {
-				return err
-			}
-			return nil
-		}
-	}
-}

app/protocol/flows/v4/blockrelay/ibd_progress_reporter.go

@@ -1,45 +0,0 @@
-package blockrelay
-
-type ibdProgressReporter struct {
-	lowDAAScore                 uint64
-	highDAAScore                uint64
-	objectName                  string
-	totalDAAScoreDifference     uint64
-	lastReportedProgressPercent int
-	processed                   int
-}
-
-func newIBDProgressReporter(lowDAAScore uint64, highDAAScore uint64, objectName string) *ibdProgressReporter {
-	if highDAAScore <= lowDAAScore {
-		// Avoid a zero or negative diff
-		highDAAScore = lowDAAScore + 1
-	}
-	return &ibdProgressReporter{
-		lowDAAScore:                 lowDAAScore,
-		highDAAScore:                highDAAScore,
-		objectName:                  objectName,
-		totalDAAScoreDifference:     highDAAScore - lowDAAScore,
-		lastReportedProgressPercent: 0,
-		processed:                   0,
-	}
-}
-
-func (ipr *ibdProgressReporter) reportProgress(processedDelta int, highestProcessedDAAScore uint64) {
-	ipr.processed += processedDelta
-
-	// Avoid exploding numbers in the percentage report, since the original `highDAAScore` might have been only a hint
-	if highestProcessedDAAScore > ipr.highDAAScore {
-		ipr.highDAAScore = highestProcessedDAAScore + 1 // + 1 for keeping it at 99%
-		ipr.totalDAAScoreDifference = ipr.highDAAScore - ipr.lowDAAScore
-	}
-	relativeDAAScore := uint64(0)
-	if highestProcessedDAAScore > ipr.lowDAAScore {
-		// Avoid a negative diff
-		relativeDAAScore = highestProcessedDAAScore - ipr.lowDAAScore
-	}
-	progressPercent := int((float64(relativeDAAScore) / float64(ipr.totalDAAScoreDifference)) * 100)
-	if progressPercent > ipr.lastReportedProgressPercent {
-		log.Infof("IBD: Processed %d %s (%d%%)", ipr.processed, ipr.objectName, progressPercent)
-		ipr.lastReportedProgressPercent = progressPercent
-	}
-}

app/protocol/flows/v4/blockrelay/ibd_with_headers_proof.go

@@ -1,394 +0,0 @@
-package blockrelay
-
-import (
-	"fmt"
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	"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"
-	"time"
-)
-
-func (flow *handleIBDFlow) ibdWithHeadersProof(highHash *externalapi.DomainHash, highBlockDAAScore uint64) error {
-	err := flow.Domain().InitStagingConsensus()
-	if err != nil {
-		return err
-	}
-
-	err = flow.downloadHeadersAndPruningUTXOSet(highHash, highBlockDAAScore)
-	if err != nil {
-		if !flow.IsRecoverableError(err) {
-			return err
-		}
-
-		log.Infof("IBD with pruning proof from %s was unsuccessful. Deleting the staging consensus.", flow.peer)
-		deleteStagingConsensusErr := flow.Domain().DeleteStagingConsensus()
-		if deleteStagingConsensusErr != nil {
-			return deleteStagingConsensusErr
-		}
-
-		return err
-	}
-
-	log.Infof("Header download stage of IBD with pruning proof completed successfully from %s. "+
-		"Committing the staging consensus and deleting the previous obsolete one if such exists.", flow.peer)
-	err = flow.Domain().CommitStagingConsensus()
-	if err != nil {
-		return err
-	}
-
-	err = flow.OnPruningPointUTXOSetOverride()
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (flow *handleIBDFlow) shouldSyncAndShouldDownloadHeadersProof(highBlock *externalapi.DomainBlock,
-	highestSharedBlockFound bool) (shouldDownload, shouldSync bool, err error) {
-
-	if !highestSharedBlockFound {
-		hasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore, err := flow.checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore(highBlock)
-		if err != nil {
-			return false, false, err
-		}
-
-		if hasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore {
-			return true, true, nil
-		}
-
-		return false, false, nil
-	}
-
-	return false, true, nil
-}
-
-func (flow *handleIBDFlow) checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore(highBlock *externalapi.DomainBlock) (bool, error) {
-	headersSelectedTip, err := flow.Domain().Consensus().GetHeadersSelectedTip()
-	if err != nil {
-		return false, err
-	}
-
-	headersSelectedTipInfo, err := flow.Domain().Consensus().GetBlockInfo(headersSelectedTip)
-	if err != nil {
-		return false, err
-	}
-
-	if highBlock.Header.BlueScore() < headersSelectedTipInfo.BlueScore+flow.Config().NetParams().PruningDepth() {
-		return false, nil
-	}
-
-	return highBlock.Header.BlueWork().Cmp(headersSelectedTipInfo.BlueWork) > 0, nil
-}
-
-func (flow *handleIBDFlow) 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 nil, err
-	}
-	message, err := flow.incomingRoute.DequeueWithTimeout(10 * time.Minute)
-	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 {
-		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 *handleIBDFlow) downloadHeadersAndPruningUTXOSet(highHash *externalapi.DomainHash, highBlockDAAScore uint64) error {
-	proofPruningPoint, err := flow.syncAndValidatePruningPointProof()
-	if err != nil {
-		return err
-	}
-
-	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 proofPruningPoint.Equal(flow.Config().NetParams().GenesisHash) {
-		return protocolerrors.Errorf(true, "the genesis pruning point violates finality")
-	}
-
-	err = flow.syncPruningPointFutureHeaders(flow.Domain().StagingConsensus(), proofPruningPoint, highHash, highBlockDAAScore)
-	if err != nil {
-		return err
-	}
-
-	log.Infof("Headers downloaded from peer %s", flow.peer)
-
-	highHashInfo, err := flow.Domain().StagingConsensus().GetBlockInfo(highHash)
-	if err != nil {
-		return err
-	}
-
-	if !highHashInfo.Exists {
-		return protocolerrors.Errorf(true, "the triggering IBD block was not sent")
-	}
-
-	err = flow.validatePruningPointFutureHeaderTimestamps()
-	if err != nil {
-		return err
-	}
-
-	log.Debugf("Syncing the current pruning point UTXO set")
-	syncedPruningPointUTXOSetSuccessfully, err := flow.syncPruningPointUTXOSet(flow.Domain().StagingConsensus(), proofPruningPoint)
-	if err != nil {
-		return err
-	}
-	if !syncedPruningPointUTXOSetSuccessfully {
-		log.Debugf("Aborting IBD because the pruning point UTXO set failed to sync")
-		return nil
-	}
-	log.Debugf("Finished syncing the current pruning point UTXO set")
-	return nil
-}
-
-func (flow *handleIBDFlow) 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 err
-	}
-
-	err = flow.validateAndInsertPruningPoints(proofPruningPoint)
-	if err != nil {
-		return err
-	}
-
-	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-	if err != nil {
-		return err
-	}
-
-	msgTrustedData, ok := message.(*appmessage.MsgTrustedData)
-	if !ok {
-		return protocolerrors.Errorf(true, "received unexpected message type. "+
-			"expected: %s, got: %s", appmessage.CmdTrustedData, message.Command())
-	}
-
-	pruningPointWithMetaData, done, err := flow.receiveBlockWithTrustedData()
-	if err != nil {
-		return err
-	}
-
-	if done {
-		return protocolerrors.Errorf(true, "got `done` message before receiving the pruning point")
-	}
-
-	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, msgTrustedData)
-	if err != nil {
-		return err
-	}
-
-	for {
-		blockWithTrustedData, done, err := flow.receiveBlockWithTrustedData()
-		if err != nil {
-			return err
-		}
-
-		if done {
-			break
-		}
-
-		err = flow.processBlockWithTrustedData(flow.Domain().StagingConsensus(), blockWithTrustedData, msgTrustedData)
-		if err != nil {
-			return err
-		}
-	}
-
-	log.Infof("Finished downloading pruning point and its anticone from %s", flow.peer)
-	return nil
-}
-
-func (flow *handleIBDFlow) processBlockWithTrustedData(
-	consensus externalapi.Consensus, block *appmessage.MsgBlockWithTrustedDataV4, data *appmessage.MsgTrustedData) error {
-
-	blockWithTrustedData := &externalapi.BlockWithTrustedData{
-		Block:        appmessage.MsgBlockToDomainBlock(block.Block),
-		DAAWindow:    make([]*externalapi.TrustedDataDataDAAHeader, 0, len(block.DAAWindowIndices)),
-		GHOSTDAGData: make([]*externalapi.BlockGHOSTDAGDataHashPair, 0, len(block.GHOSTDAGDataIndices)),
-	}
-
-	for _, index := range block.DAAWindowIndices {
-		blockWithTrustedData.DAAWindow = append(blockWithTrustedData.DAAWindow, appmessage.TrustedDataDataDAABlockV4ToTrustedDataDataDAAHeader(data.DAAWindow[index]))
-	}
-
-	for _, index := range block.GHOSTDAGDataIndices {
-		blockWithTrustedData.GHOSTDAGData = append(blockWithTrustedData.GHOSTDAGData, appmessage.GHOSTDAGHashPairToDomainGHOSTDAGHashPair(data.GHOSTDAGData[index]))
-	}
-
-	_, err := consensus.ValidateAndInsertBlockWithTrustedData(blockWithTrustedData, false)
-	return err
-}
-
-func (flow *handleIBDFlow) receiveBlockWithTrustedData() (*appmessage.MsgBlockWithTrustedDataV4, bool, error) {
-	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-	if err != nil {
-		return nil, false, err
-	}
-
-	switch downCastedMessage := message.(type) {
-	case *appmessage.MsgBlockWithTrustedDataV4:
-		return downCastedMessage, false, nil
-	case *appmessage.MsgDoneBlocksWithTrustedData:
-		return nil, true, nil
-	default:
-		return nil, false,
-			protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s or %s, got: %s",
-				(&appmessage.MsgBlockWithTrustedData{}).Command(),
-				(&appmessage.MsgDoneBlocksWithTrustedData{}).Command(),
-				downCastedMessage.Command())
-	}
-}
-
-func (flow *handleIBDFlow) receivePruningPoints() (*appmessage.MsgPruningPoints, error) {
-	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-	if err != nil {
-		return nil, err
-	}
-
-	msgPruningPoints, ok := message.(*appmessage.MsgPruningPoints)
-	if !ok {
-		return nil,
-			protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s, got: %s", appmessage.CmdPruningPoints, message.Command())
-	}
-
-	return msgPruningPoints, nil
-}
-
-func (flow *handleIBDFlow) 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
-	}
-
-	headers := make([]externalapi.BlockHeader, len(pruningPoints.Headers))
-	for i, header := range pruningPoints.Headers {
-		headers[i] = appmessage.BlockHeaderToDomainBlockHeader(header)
-	}
-
-	arePruningPointsViolatingFinality, err := flow.Domain().Consensus().ArePruningPointsViolatingFinality(headers)
-	if err != nil {
-		return err
-	}
-
-	if arePruningPointsViolatingFinality {
-		// TODO: Find a better way to deal with finality conflicts.
-		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
-	}
-
-	return nil
-}
-
-func (flow *handleIBDFlow) syncPruningPointUTXOSet(consensus externalapi.Consensus,
-	pruningPoint *externalapi.DomainHash) (bool, error) {
-
-	log.Infof("Checking if the suggested pruning point %s is compatible to the node DAG", pruningPoint)
-	isValid, err := flow.Domain().StagingConsensus().IsValidPruningPoint(pruningPoint)
-	if err != nil {
-		return false, err
-	}
-
-	if !isValid {
-		return false, protocolerrors.Errorf(true, "invalid pruning point %s", pruningPoint)
-	}
-
-	log.Info("Fetching the pruning point UTXO set")
-	isSuccessful, err := flow.fetchMissingUTXOSet(consensus, pruningPoint)
-	if err != nil {
-		log.Infof("An error occurred while fetching the pruning point UTXO set. Stopping IBD. (%s)", err)
-		return false, err
-	}
-
-	if !isSuccessful {
-		log.Infof("Couldn't successfully fetch the pruning point UTXO set. Stopping IBD.")
-		return false, nil
-	}
-
-	log.Info("Fetched the new pruning point UTXO set")
-	return true, nil
-}
-
-func (flow *handleIBDFlow) fetchMissingUTXOSet(consensus externalapi.Consensus, pruningPointHash *externalapi.DomainHash) (succeed bool, err error) {
-	defer func() {
-		err := flow.Domain().StagingConsensus().ClearImportedPruningPointData()
-		if err != nil {
-			panic(fmt.Sprintf("failed to clear imported pruning point data: %s", err))
-		}
-	}()
-
-	err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestPruningPointUTXOSet(pruningPointHash))
-	if err != nil {
-		return false, err
-	}
-
-	receivedAll, err := flow.receiveAndInsertPruningPointUTXOSet(consensus, pruningPointHash)
-	if err != nil {
-		return false, err
-	}
-	if !receivedAll {
-		return false, nil
-	}
-
-	err = flow.Domain().StagingConsensus().ValidateAndInsertImportedPruningPoint(pruningPointHash)
-	if err != nil {
-		// TODO: Find a better way to deal with finality conflicts.
-		if errors.Is(err, ruleerrors.ErrSuggestedPruningViolatesFinality) {
-			return false, nil
-		}
-		return false, protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "error with pruning point UTXO set")
-	}
-
-	return true, nil
-}

app/protocol/flows/v4/blockrelay/log.go

@@ -1,9 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/infrastructure/logger"
-	"github.com/kaspanet/kaspad/util/panics"
-)
-
-var log = logger.RegisterSubSystem("PROT")
-var spawn = panics.GoroutineWrapperFunc(log)

app/protocol/flows/v4/blockrelay/send_virtual_selected_parent_inv.go

@@ -1,35 +0,0 @@
-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/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// SendVirtualSelectedParentInvContext is the interface for the context needed for the SendVirtualSelectedParentInv flow.
-type SendVirtualSelectedParentInvContext interface {
-	Domain() domain.Domain
-	Config() *config.Config
-}
-
-// SendVirtualSelectedParentInv sends a peer the selected parent hash of the virtual
-func SendVirtualSelectedParentInv(context SendVirtualSelectedParentInvContext,
-	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
-
-	virtualSelectedParent, err := context.Domain().Consensus().GetVirtualSelectedParent()
-	if err != nil {
-		return err
-	}
-
-	if virtualSelectedParent.Equal(context.Config().NetParams().GenesisHash) {
-		log.Debugf("Skipping sending the virtual selected parent hash to peer %s because it's the genesis", peer)
-		return nil
-	}
-
-	log.Debugf("Sending virtual selected parent hash %s to peer %s", virtualSelectedParent, peer)
-
-	virtualSelectedParentInv := appmessage.NewMsgInvBlock(virtualSelectedParent)
-	return outgoingRoute.Enqueue(virtualSelectedParentInv)
-}

app/protocol/flows/v4/ping/receive.go

@@ -1,42 +0,0 @@
-package ping
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// ReceivePingsContext is the interface for the context needed for the ReceivePings flow.
-type ReceivePingsContext interface {
-}
-
-type receivePingsFlow struct {
-	ReceivePingsContext
-	incomingRoute, outgoingRoute *router.Route
-}
-
-// ReceivePings handles all ping messages coming through incomingRoute.
-// This function assumes that incomingRoute will only return MsgPing.
-func ReceivePings(context ReceivePingsContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
-	flow := &receivePingsFlow{
-		ReceivePingsContext: context,
-		incomingRoute:       incomingRoute,
-		outgoingRoute:       outgoingRoute,
-	}
-	return flow.start()
-}
-
-func (flow *receivePingsFlow) start() error {
-	for {
-		message, err := flow.incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-		pingMessage := message.(*appmessage.MsgPing)
-
-		pongMessage := appmessage.NewMsgPong(pingMessage.Nonce)
-		err = flow.outgoingRoute.Enqueue(pongMessage)
-		if err != nil {
-			return err
-		}
-	}
-}

app/protocol/flows/v4/ping/send.go

@@ -1,77 +0,0 @@
-package ping
-
-import (
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	"github.com/kaspanet/kaspad/app/protocol/flowcontext"
-	"github.com/pkg/errors"
-	"time"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util/random"
-)
-
-// SendPingsContext is the interface for the context needed for the SendPings flow.
-type SendPingsContext interface {
-	ShutdownChan() <-chan struct{}
-}
-
-type sendPingsFlow struct {
-	SendPingsContext
-	incomingRoute, outgoingRoute *router.Route
-	peer                         *peerpkg.Peer
-}
-
-// SendPings starts sending MsgPings every pingInterval seconds to the
-// given peer.
-// This function assumes that incomingRoute will only return MsgPong.
-func SendPings(context SendPingsContext, incomingRoute *router.Route, outgoingRoute *router.Route, peer *peerpkg.Peer) error {
-	flow := &sendPingsFlow{
-		SendPingsContext: context,
-		incomingRoute:    incomingRoute,
-		outgoingRoute:    outgoingRoute,
-		peer:             peer,
-	}
-	return flow.start()
-}
-
-func (flow *sendPingsFlow) start() error {
-	const pingInterval = 2 * time.Minute
-	ticker := time.NewTicker(pingInterval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-flow.ShutdownChan():
-			return nil
-		case <-ticker.C:
-		}
-
-		nonce, err := random.Uint64()
-		if err != nil {
-			return err
-		}
-		flow.peer.SetPingPending(nonce)
-
-		pingMessage := appmessage.NewMsgPing(nonce)
-		err = flow.outgoingRoute.Enqueue(pingMessage)
-		if err != nil {
-			return err
-		}
-
-		message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-		if err != nil {
-			if errors.Is(err, router.ErrTimeout) {
-				return errors.Wrapf(flowcontext.ErrPingTimeout, err.Error())
-			}
-			return err
-		}
-		pongMessage := message.(*appmessage.MsgPong)
-		if pongMessage.Nonce != pingMessage.Nonce {
-			return protocolerrors.New(true, "nonce mismatch between ping and pong")
-		}
-		flow.peer.SetPingIdle()
-	}
-}

app/protocol/flows/v4/register.go

@@ -1,194 +0,0 @@
-package v4
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	"github.com/kaspanet/kaspad/app/protocol/flowcontext"
-	"github.com/kaspanet/kaspad/app/protocol/flows/v4/addressexchange"
-	"github.com/kaspanet/kaspad/app/protocol/flows/v4/blockrelay"
-	"github.com/kaspanet/kaspad/app/protocol/flows/v4/ping"
-	"github.com/kaspanet/kaspad/app/protocol/flows/v4/rejects"
-	"github.com/kaspanet/kaspad/app/protocol/flows/v4/transactionrelay"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	routerpkg "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-type protocolManager interface {
-	RegisterFlow(name string, router *routerpkg.Router, messageTypes []appmessage.MessageCommand, isStopping *uint32,
-		errChan chan error, initializeFunc common.FlowInitializeFunc) *common.Flow
-	RegisterOneTimeFlow(name string, router *routerpkg.Router, messageTypes []appmessage.MessageCommand,
-		isStopping *uint32, stopChan chan error, initializeFunc common.FlowInitializeFunc) *common.Flow
-	RegisterFlowWithCapacity(name string, capacity int, router *routerpkg.Router,
-		messageTypes []appmessage.MessageCommand, isStopping *uint32,
-		errChan chan error, initializeFunc common.FlowInitializeFunc) *common.Flow
-	Context() *flowcontext.FlowContext
-}
-
-// Register is used in order to register all the protocol flows to the given router.
-func Register(m protocolManager, router *routerpkg.Router, errChan chan error, isStopping *uint32) (flows []*common.Flow) {
-	flows = registerAddressFlows(m, router, isStopping, errChan)
-	flows = append(flows, registerBlockRelayFlows(m, router, isStopping, errChan)...)
-	flows = append(flows, registerPingFlows(m, router, isStopping, errChan)...)
-	flows = append(flows, registerTransactionRelayFlow(m, router, isStopping, errChan)...)
-	flows = append(flows, registerRejectsFlow(m, router, isStopping, errChan)...)
-
-	return flows
-}
-
-func registerAddressFlows(m protocolManager, router *routerpkg.Router, isStopping *uint32, errChan chan error) []*common.Flow {
-	outgoingRoute := router.OutgoingRoute()
-
-	return []*common.Flow{
-		m.RegisterFlow("SendAddresses", router, []appmessage.MessageCommand{appmessage.CmdRequestAddresses}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return addressexchange.SendAddresses(m.Context(), incomingRoute, outgoingRoute)
-			},
-		),
-
-		m.RegisterOneTimeFlow("ReceiveAddresses", router, []appmessage.MessageCommand{appmessage.CmdAddresses}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return addressexchange.ReceiveAddresses(m.Context(), incomingRoute, outgoingRoute, peer)
-			},
-		),
-	}
-}
-
-func registerBlockRelayFlows(m protocolManager, router *routerpkg.Router, isStopping *uint32, errChan chan error) []*common.Flow {
-	outgoingRoute := router.OutgoingRoute()
-
-	return []*common.Flow{
-		m.RegisterOneTimeFlow("SendVirtualSelectedParentInv", router, []appmessage.MessageCommand{},
-			isStopping, errChan, func(route *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.SendVirtualSelectedParentInv(m.Context(), outgoingRoute, peer)
-			}),
-
-		m.RegisterFlow("HandleRelayInvs", router, []appmessage.MessageCommand{
-			appmessage.CmdInvRelayBlock, appmessage.CmdBlock, appmessage.CmdBlockLocator,
-		},
-			isStopping, errChan, func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRelayInvs(m.Context(), incomingRoute,
-					outgoingRoute, peer)
-			},
-		),
-
-		m.RegisterFlow("HandleIBD", router, []appmessage.MessageCommand{
-			appmessage.CmdDoneHeaders, appmessage.CmdUnexpectedPruningPoint, appmessage.CmdPruningPointUTXOSetChunk,
-			appmessage.CmdBlockHeaders, appmessage.CmdIBDBlockLocatorHighestHash, appmessage.CmdBlockWithTrustedDataV4,
-			appmessage.CmdDoneBlocksWithTrustedData, appmessage.CmdIBDBlockLocatorHighestHashNotFound,
-			appmessage.CmdDonePruningPointUTXOSetChunks, appmessage.CmdIBDBlock, appmessage.CmdPruningPoints,
-			appmessage.CmdPruningPointProof,
-			appmessage.CmdTrustedData,
-		},
-			isStopping, errChan, func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleIBD(m.Context(), incomingRoute,
-					outgoingRoute, peer)
-			},
-		),
-
-		m.RegisterFlow("HandleRelayBlockRequests", router, []appmessage.MessageCommand{appmessage.CmdRequestRelayBlocks}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRelayBlockRequests(m.Context(), incomingRoute, outgoingRoute, peer)
-			},
-		),
-
-		m.RegisterFlow("HandleRequestBlockLocator", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestBlockLocator}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRequestBlockLocator(m.Context(), incomingRoute, outgoingRoute)
-			},
-		),
-
-		m.RegisterFlow("HandleRequestHeaders", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestHeaders, appmessage.CmdRequestNextHeaders}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRequestHeaders(m.Context(), incomingRoute, outgoingRoute, peer)
-			},
-		),
-
-		m.RegisterFlow("HandleIBDBlockRequests", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestIBDBlocks}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleIBDBlockRequests(m.Context(), incomingRoute, outgoingRoute)
-			},
-		),
-
-		m.RegisterFlow("HandleRequestPruningPointUTXOSet", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointUTXOSet,
-				appmessage.CmdRequestNextPruningPointUTXOSetChunk}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRequestPruningPointUTXOSet(m.Context(), incomingRoute, outgoingRoute)
-			},
-		),
-
-		m.RegisterFlow("HandlePruningPointAndItsAnticoneRequests", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointAndItsAnticone}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandlePruningPointAndItsAnticoneRequests(m.Context(), incomingRoute, outgoingRoute, peer)
-			},
-		),
-
-		m.RegisterFlow("HandleIBDBlockLocator", router,
-			[]appmessage.MessageCommand{appmessage.CmdIBDBlockLocator}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				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)
-			},
-		),
-	}
-}
-
-func registerPingFlows(m protocolManager, router *routerpkg.Router, isStopping *uint32, errChan chan error) []*common.Flow {
-	outgoingRoute := router.OutgoingRoute()
-
-	return []*common.Flow{
-		m.RegisterFlow("ReceivePings", router, []appmessage.MessageCommand{appmessage.CmdPing}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return ping.ReceivePings(m.Context(), incomingRoute, outgoingRoute)
-			},
-		),
-
-		m.RegisterFlow("SendPings", router, []appmessage.MessageCommand{appmessage.CmdPong}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return ping.SendPings(m.Context(), incomingRoute, outgoingRoute, peer)
-			},
-		),
-	}
-}
-
-func registerTransactionRelayFlow(m protocolManager, router *routerpkg.Router, isStopping *uint32, errChan chan error) []*common.Flow {
-	outgoingRoute := router.OutgoingRoute()
-
-	return []*common.Flow{
-		m.RegisterFlowWithCapacity("HandleRelayedTransactions", 10_000, router,
-			[]appmessage.MessageCommand{appmessage.CmdInvTransaction, appmessage.CmdTx, appmessage.CmdTransactionNotFound}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return transactionrelay.HandleRelayedTransactions(m.Context(), incomingRoute, outgoingRoute)
-			},
-		),
-		m.RegisterFlow("HandleRequestTransactions", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestTransactions}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return transactionrelay.HandleRequestedTransactions(m.Context(), incomingRoute, outgoingRoute)
-			},
-		),
-	}
-}
-
-func registerRejectsFlow(m protocolManager, router *routerpkg.Router, isStopping *uint32, errChan chan error) []*common.Flow {
-	outgoingRoute := router.OutgoingRoute()
-
-	return []*common.Flow{
-		m.RegisterFlow("HandleRejects", router,
-			[]appmessage.MessageCommand{appmessage.CmdReject}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return rejects.HandleRejects(m.Context(), incomingRoute, outgoingRoute)
-			},
-		),
-	}
-}

app/protocol/flows/v4/rejects/handle_rejects.go

@@ -1,37 +0,0 @@
-package rejects
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleRejectsContext is the interface for the context needed for the HandleRejects flow.
-type HandleRejectsContext interface {
-}
-
-type handleRejectsFlow struct {
-	HandleRejectsContext
-	incomingRoute, outgoingRoute *router.Route
-}
-
-// HandleRejects handles all reject messages coming through incomingRoute.
-// This function assumes that incomingRoute will only return MsgReject.
-func HandleRejects(context HandleRejectsContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
-	flow := &handleRejectsFlow{
-		HandleRejectsContext: context,
-		incomingRoute:        incomingRoute,
-		outgoingRoute:        outgoingRoute,
-	}
-	return flow.start()
-}
-
-func (flow *handleRejectsFlow) start() error {
-	message, err := flow.incomingRoute.Dequeue()
-	if err != nil {
-		return err
-	}
-	rejectMessage := message.(*appmessage.MsgReject)
-
-	return protocolerrors.Errorf(false, "got reject message: `%s`", rejectMessage.Reason)
-}

app/protocol/flows/v4/testing/common_test.go

@@ -1,24 +0,0 @@
-package testing
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/pkg/errors"
-)
-
-func checkFlowError(t *testing.T, err error, isProtocolError bool, shouldBan bool, contains string) {
-	pErr := protocolerrors.ProtocolError{}
-	if errors.As(err, &pErr) != isProtocolError {
-		t.Fatalf("Unexepcted error %+v", err)
-	}
-
-	if pErr.ShouldBan != shouldBan {
-		t.Fatalf("Exepcted shouldBan %t but got %t", shouldBan, pErr.ShouldBan)
-	}
-
-	if !strings.Contains(err.Error(), contains) {
-		t.Fatalf("Unexpected error. Expected error to contain '%s' but got: %+v", contains, err)
-	}
-}

app/protocol/flows/v4/testing/receiveaddresses_test.go

@@ -1,51 +0,0 @@
-package testing
-
-import (
-	"github.com/kaspanet/kaspad/app/protocol/flows/v4/addressexchange"
-	"testing"
-	"time"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/domain/consensus"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-type fakeReceiveAddressesContext struct{}
-
-func (f fakeReceiveAddressesContext) AddressManager() *addressmanager.AddressManager {
-	return nil
-}
-
-func TestReceiveAddressesErrors(t *testing.T) {
-	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
-		incomingRoute := router.NewRoute("incoming")
-		outgoingRoute := router.NewRoute("outgoing")
-		peer := peerpkg.New(nil)
-		errChan := make(chan error)
-		go func() {
-			errChan <- addressexchange.ReceiveAddresses(fakeReceiveAddressesContext{}, incomingRoute, outgoingRoute, peer)
-		}()
-
-		_, err := outgoingRoute.DequeueWithTimeout(time.Second)
-		if err != nil {
-			t.Fatalf("DequeueWithTimeout: %+v", err)
-		}
-
-		// Sending addressmanager.GetAddressesMax+1 addresses should trigger a ban
-		err = incomingRoute.Enqueue(appmessage.NewMsgAddresses(make([]*appmessage.NetAddress,
-			addressmanager.GetAddressesMax+1)))
-		if err != nil {
-			t.Fatalf("Enqueue: %+v", err)
-		}
-
-		select {
-		case err := <-errChan:
-			checkFlowError(t, err, true, true, "address count exceeded")
-		case <-time.After(time.Second):
-			t.Fatalf("timed out after %s", time.Second)
-		}
-	})
-}

app/protocol/flows/v4/testing/testing.go

@@ -1,4 +0,0 @@
-package testing
-
-// Because of a bug in Go coverage fails if you have packages with test files only. See https://github.com/golang/go/issues/27333
-// So this is a dummy non-test go file in the package.

app/protocol/flows/v4/transactionrelay/handle_relayed_transactions.go

@@ -1,214 +0,0 @@
-package transactionrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	"github.com/kaspanet/kaspad/app/protocol/flowcontext"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/pkg/errors"
-)
-
-// TransactionsRelayContext is the interface for the context needed for the
-// HandleRelayedTransactions and HandleRequestedTransactions flows.
-type TransactionsRelayContext interface {
-	NetAdapter() *netadapter.NetAdapter
-	Domain() domain.Domain
-	SharedRequestedTransactions() *flowcontext.SharedRequestedTransactions
-	OnTransactionAddedToMempool()
-	EnqueueTransactionIDsForPropagation(transactionIDs []*externalapi.DomainTransactionID) error
-	IsNearlySynced() (bool, error)
-}
-
-type handleRelayedTransactionsFlow struct {
-	TransactionsRelayContext
-	incomingRoute, outgoingRoute *router.Route
-	invsQueue                    []*appmessage.MsgInvTransaction
-}
-
-// HandleRelayedTransactions listens to appmessage.MsgInvTransaction messages, requests their corresponding transactions if they
-// are missing, adds them to the mempool and propagates them to the rest of the network.
-func HandleRelayedTransactions(context TransactionsRelayContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
-	flow := &handleRelayedTransactionsFlow{
-		TransactionsRelayContext: context,
-		incomingRoute:            incomingRoute,
-		outgoingRoute:            outgoingRoute,
-		invsQueue:                make([]*appmessage.MsgInvTransaction, 0),
-	}
-	return flow.start()
-}
-
-func (flow *handleRelayedTransactionsFlow) start() error {
-	for {
-		inv, err := flow.readInv()
-		if err != nil {
-			return err
-		}
-
-		isNearlySynced, err := flow.IsNearlySynced()
-		if err != nil {
-			return err
-		}
-		// Transaction relay is disabled if the node is out of sync and thus not mining
-		if !isNearlySynced {
-			continue
-		}
-
-		requestedIDs, err := flow.requestInvTransactions(inv)
-		if err != nil {
-			return err
-		}
-
-		err = flow.receiveTransactions(requestedIDs)
-		if err != nil {
-			return err
-		}
-	}
-}
-
-func (flow *handleRelayedTransactionsFlow) requestInvTransactions(
-	inv *appmessage.MsgInvTransaction) (requestedIDs []*externalapi.DomainTransactionID, err error) {
-
-	idsToRequest := make([]*externalapi.DomainTransactionID, 0, len(inv.TxIDs))
-	for _, txID := range inv.TxIDs {
-		if flow.isKnownTransaction(txID) {
-			continue
-		}
-		exists := flow.SharedRequestedTransactions().AddIfNotExists(txID)
-		if exists {
-			continue
-		}
-		idsToRequest = append(idsToRequest, txID)
-	}
-
-	if len(idsToRequest) == 0 {
-		return idsToRequest, nil
-	}
-
-	msgGetTransactions := appmessage.NewMsgRequestTransactions(idsToRequest)
-	err = flow.outgoingRoute.Enqueue(msgGetTransactions)
-	if err != nil {
-		flow.SharedRequestedTransactions().RemoveMany(idsToRequest)
-		return nil, err
-	}
-	return idsToRequest, nil
-}
-
-func (flow *handleRelayedTransactionsFlow) isKnownTransaction(txID *externalapi.DomainTransactionID) bool {
-	// Ask the transaction memory pool if the transaction is known
-	// to it in any form (main pool or orphan).
-	if _, ok := flow.Domain().MiningManager().GetTransaction(txID); ok {
-		return true
-	}
-
-	return false
-}
-
-func (flow *handleRelayedTransactionsFlow) readInv() (*appmessage.MsgInvTransaction, error) {
-	if len(flow.invsQueue) > 0 {
-		var inv *appmessage.MsgInvTransaction
-		inv, flow.invsQueue = flow.invsQueue[0], flow.invsQueue[1:]
-		return inv, nil
-	}
-
-	msg, err := flow.incomingRoute.Dequeue()
-	if err != nil {
-		return nil, err
-	}
-
-	inv, ok := msg.(*appmessage.MsgInvTransaction)
-	if !ok {
-		return nil, protocolerrors.Errorf(true, "unexpected %s message in the block relay flow while "+
-			"expecting an inv message", msg.Command())
-	}
-	return inv, nil
-}
-
-func (flow *handleRelayedTransactionsFlow) broadcastAcceptedTransactions(acceptedTxIDs []*externalapi.DomainTransactionID) error {
-	return flow.EnqueueTransactionIDsForPropagation(acceptedTxIDs)
-}
-
-// readMsgTxOrNotFound returns the next msgTx or msgTransactionNotFound in incomingRoute,
-// returning only one of the message types at a time.
-//
-// and populates invsQueue with any inv messages that meanwhile arrive.
-func (flow *handleRelayedTransactionsFlow) readMsgTxOrNotFound() (
-	msgTx *appmessage.MsgTx, msgNotFound *appmessage.MsgTransactionNotFound, err error) {
-
-	for {
-		message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-		if err != nil {
-			return nil, nil, err
-		}
-
-		switch message := message.(type) {
-		case *appmessage.MsgInvTransaction:
-			flow.invsQueue = append(flow.invsQueue, message)
-		case *appmessage.MsgTx:
-			return message, nil, nil
-		case *appmessage.MsgTransactionNotFound:
-			return nil, message, nil
-		default:
-			return nil, nil, errors.Errorf("unexpected message %s", message.Command())
-		}
-	}
-}
-
-func (flow *handleRelayedTransactionsFlow) receiveTransactions(requestedTransactions []*externalapi.DomainTransactionID) error {
-	// In case the function returns earlier than expected, we want to make sure sharedRequestedTransactions is
-	// clean from any pending transactions.
-	defer flow.SharedRequestedTransactions().RemoveMany(requestedTransactions)
-	for _, expectedID := range requestedTransactions {
-		msgTx, msgTxNotFound, err := flow.readMsgTxOrNotFound()
-		if err != nil {
-			return err
-		}
-		if msgTxNotFound != nil {
-			if !msgTxNotFound.ID.Equal(expectedID) {
-				return protocolerrors.Errorf(true, "expected transaction %s, but got %s",
-					expectedID, msgTxNotFound.ID)
-			}
-
-			continue
-		}
-		tx := appmessage.MsgTxToDomainTransaction(msgTx)
-		txID := consensushashing.TransactionID(tx)
-		if !txID.Equal(expectedID) {
-			return protocolerrors.Errorf(true, "expected transaction %s, but got %s",
-				expectedID, txID)
-		}
-
-		acceptedTransactions, err :=
-			flow.Domain().MiningManager().ValidateAndInsertTransaction(tx, false, true)
-		if err != nil {
-			ruleErr := &mempool.RuleError{}
-			if !errors.As(err, ruleErr) {
-				return errors.Wrapf(err, "failed to process transaction %s", txID)
-			}
-
-			shouldBan := false
-			if txRuleErr := (&mempool.TxRuleError{}); errors.As(ruleErr.Err, txRuleErr) {
-				if txRuleErr.RejectCode == mempool.RejectInvalid {
-					shouldBan = true
-				}
-			}
-
-			if !shouldBan {
-				continue
-			}
-
-			return protocolerrors.Errorf(true, "rejected transaction %s: %s", txID, ruleErr)
-		}
-		err = flow.broadcastAcceptedTransactions(consensushashing.TransactionIDs(acceptedTransactions))
-		if err != nil {
-			return err
-		}
-		flow.OnTransactionAddedToMempool()
-	}
-	return nil
-}

app/protocol/flows/v4/transactionrelay/handle_relayed_transactions_test.go

@@ -1,196 +0,0 @@
-package transactionrelay_test
-
-import (
-	"errors"
-	"github.com/kaspanet/kaspad/app/protocol/flowcontext"
-	"github.com/kaspanet/kaspad/app/protocol/flows/v4/transactionrelay"
-	"strings"
-	"testing"
-
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
-	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
-	"github.com/kaspanet/kaspad/infrastructure/logger"
-	"github.com/kaspanet/kaspad/util/panics"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-type mocTransactionsRelayContext struct {
-	netAdapter                  *netadapter.NetAdapter
-	domain                      domain.Domain
-	sharedRequestedTransactions *flowcontext.SharedRequestedTransactions
-}
-
-func (m *mocTransactionsRelayContext) NetAdapter() *netadapter.NetAdapter {
-	return m.netAdapter
-}
-
-func (m *mocTransactionsRelayContext) Domain() domain.Domain {
-	return m.domain
-}
-
-func (m *mocTransactionsRelayContext) SharedRequestedTransactions() *flowcontext.SharedRequestedTransactions {
-	return m.sharedRequestedTransactions
-}
-
-func (m *mocTransactionsRelayContext) EnqueueTransactionIDsForPropagation(transactionIDs []*externalapi.DomainTransactionID) error {
-	return nil
-}
-
-func (m *mocTransactionsRelayContext) OnTransactionAddedToMempool() {
-}
-
-func (m *mocTransactionsRelayContext) IsNearlySynced() (bool, error) {
-	return true, nil
-}
-
-// TestHandleRelayedTransactionsNotFound tests the flow of  HandleRelayedTransactions when the peer doesn't
-// have the requested transactions in the mempool.
-func TestHandleRelayedTransactionsNotFound(t *testing.T) {
-	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
-
-		var log = logger.RegisterSubSystem("PROT")
-		var spawn = panics.GoroutineWrapperFunc(log)
-		factory := consensus.NewFactory()
-		tc, teardown, err := factory.NewTestConsensus(consensusConfig, "TestHandleRelayedTransactionsNotFound")
-		if err != nil {
-			t.Fatalf("Error setting up test consensus: %+v", err)
-		}
-		defer teardown(false)
-
-		sharedRequestedTransactions := flowcontext.NewSharedRequestedTransactions()
-		adapter, err := netadapter.NewNetAdapter(config.DefaultConfig())
-		if err != nil {
-			t.Fatalf("Failed to create a NetAdapter: %v", err)
-		}
-		domainInstance, err := domain.New(consensusConfig, mempool.DefaultConfig(&consensusConfig.Params), tc.Database())
-		if err != nil {
-			t.Fatalf("Failed to set up a domain instance: %v", err)
-		}
-		context := &mocTransactionsRelayContext{
-			netAdapter:                  adapter,
-			domain:                      domainInstance,
-			sharedRequestedTransactions: sharedRequestedTransactions,
-		}
-		incomingRoute := router.NewRoute("incoming")
-		defer incomingRoute.Close()
-		peerIncomingRoute := router.NewRoute("outgoing")
-		defer peerIncomingRoute.Close()
-
-		txID1 := externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01})
-		txID2 := externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02})
-		txIDs := []*externalapi.DomainTransactionID{txID1, txID2}
-		invMessage := appmessage.NewMsgInvTransaction(txIDs)
-		err = incomingRoute.Enqueue(invMessage)
-		if err != nil {
-			t.Fatalf("Unexpected error from incomingRoute.Enqueue: %v", err)
-		}
-		// The goroutine is representing the peer's actions.
-		spawn("peerResponseToTheTransactionsRequest", func() {
-			msg, err := peerIncomingRoute.Dequeue()
-			if err != nil {
-				t.Fatalf("Dequeue: %v", err)
-			}
-			inv := msg.(*appmessage.MsgRequestTransactions)
-
-			if len(txIDs) != len(inv.IDs) {
-				t.Fatalf("TestHandleRelayedTransactions: expected %d transactions ID, but got %d", len(txIDs), len(inv.IDs))
-			}
-
-			for i, id := range inv.IDs {
-				if txIDs[i].String() != id.String() {
-					t.Fatalf("TestHandleRelayedTransactions: expected equal txID: expected %s, but got %s", txIDs[i].String(), id.String())
-				}
-				err = incomingRoute.Enqueue(appmessage.NewMsgTransactionNotFound(txIDs[i]))
-				if err != nil {
-					t.Fatalf("Unexpected error from incomingRoute.Enqueue: %v", err)
-				}
-			}
-			// Insert an unexpected message type to stop the infinity loop.
-			err = incomingRoute.Enqueue(&appmessage.MsgAddresses{})
-			if err != nil {
-				t.Fatalf("Unexpected error from incomingRoute.Enqueue: %v", err)
-			}
-		})
-
-		err = transactionrelay.HandleRelayedTransactions(context, incomingRoute, peerIncomingRoute)
-		// Since we inserted an unexpected message type to stop the infinity loop,
-		// we expect the error will be infected from this specific message and also the
-		// error will count as a protocol message.
-		if protocolErr := (protocolerrors.ProtocolError{}); err == nil || !errors.As(err, &protocolErr) {
-			t.Fatalf("Expected to protocol error")
-		} else {
-			if !protocolErr.ShouldBan {
-				t.Fatalf("Exepcted shouldBan true, but got false.")
-			}
-			if !strings.Contains(err.Error(), "unexpected Addresses [code 3] message in the block relay flow while expecting an inv message") {
-				t.Fatalf("Unexpected error: expected: an error due to existence of an Addresses message "+
-					"in the block relay flow, but got: %v", protocolErr.Cause)
-			}
-		}
-	})
-}
-
-// TestOnClosedIncomingRoute verifies that an appropriate error message will be returned when
-// trying to dequeue a message from a closed route.
-func TestOnClosedIncomingRoute(t *testing.T) {
-	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
-
-		factory := consensus.NewFactory()
-		tc, teardown, err := factory.NewTestConsensus(consensusConfig, "TestOnClosedIncomingRoute")
-		if err != nil {
-			t.Fatalf("Error setting up test consensus: %+v", err)
-		}
-		defer teardown(false)
-
-		sharedRequestedTransactions := flowcontext.NewSharedRequestedTransactions()
-		adapter, err := netadapter.NewNetAdapter(config.DefaultConfig())
-		if err != nil {
-			t.Fatalf("Failed to creat a NetAdapter : %v", err)
-		}
-		domainInstance, err := domain.New(consensusConfig, mempool.DefaultConfig(&consensusConfig.Params), tc.Database())
-		if err != nil {
-			t.Fatalf("Failed to set up a domain instance: %v", err)
-		}
-		context := &mocTransactionsRelayContext{
-			netAdapter:                  adapter,
-			domain:                      domainInstance,
-			sharedRequestedTransactions: sharedRequestedTransactions,
-		}
-		incomingRoute := router.NewRoute("incoming")
-		outgoingRoute := router.NewRoute("outgoing")
-		defer outgoingRoute.Close()
-
-		txID := externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01})
-		txIDs := []*externalapi.DomainTransactionID{txID}
-
-		err = incomingRoute.Enqueue(&appmessage.MsgInvTransaction{TxIDs: txIDs})
-		if err != nil {
-			t.Fatalf("Unexpected error from incomingRoute.Enqueue: %v", err)
-		}
-		incomingRoute.Close()
-		err = transactionrelay.HandleRelayedTransactions(context, incomingRoute, outgoingRoute)
-		if err == nil || !errors.Is(err, router.ErrRouteClosed) {
-			t.Fatalf("Unexpected error: expected: %v, got : %v", router.ErrRouteClosed, err)
-		}
-	})
-}

app/protocol/flows/v4/transactionrelay/handle_requested_transactions.go

@@ -1,59 +0,0 @@
-package transactionrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-type handleRequestedTransactionsFlow struct {
-	TransactionsRelayContext
-	incomingRoute, outgoingRoute *router.Route
-}
-
-// HandleRequestedTransactions listens to appmessage.MsgRequestTransactions messages, responding with the requested
-// transactions if those are in the mempool.
-// Missing transactions would be ignored
-func HandleRequestedTransactions(context TransactionsRelayContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
-	flow := &handleRequestedTransactionsFlow{
-		TransactionsRelayContext: context,
-		incomingRoute:            incomingRoute,
-		outgoingRoute:            outgoingRoute,
-	}
-	return flow.start()
-}
-
-func (flow *handleRequestedTransactionsFlow) start() error {
-	for {
-		msgRequestTransactions, err := flow.readRequestTransactions()
-		if err != nil {
-			return err
-		}
-
-		for _, transactionID := range msgRequestTransactions.IDs {
-			tx, ok := flow.Domain().MiningManager().GetTransaction(transactionID)
-
-			if !ok {
-				msgTransactionNotFound := appmessage.NewMsgTransactionNotFound(transactionID)
-				err := flow.outgoingRoute.Enqueue(msgTransactionNotFound)
-				if err != nil {
-					return err
-				}
-				continue
-			}
-
-			err := flow.outgoingRoute.Enqueue(appmessage.DomainTransactionToMsgTx(tx))
-			if err != nil {
-				return err
-			}
-		}
-	}
-}
-
-func (flow *handleRequestedTransactionsFlow) readRequestTransactions() (*appmessage.MsgRequestTransactions, error) {
-	msg, err := flow.incomingRoute.Dequeue()
-	if err != nil {
-		return nil, err
-	}
-
-	return msg.(*appmessage.MsgRequestTransactions), nil
-}

app/protocol/flows/v4/transactionrelay/handle_requested_transactions_test.go

@@ -1,91 +0,0 @@
-package transactionrelay_test
-
-import (
-	"github.com/kaspanet/kaspad/app/protocol/flowcontext"
-	"github.com/kaspanet/kaspad/app/protocol/flows/v4/transactionrelay"
-	"testing"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
-	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/logger"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util/panics"
-	"github.com/pkg/errors"
-)
-
-// TestHandleRequestedTransactionsNotFound tests the flow of  HandleRequestedTransactions
-// when the requested transactions don't found in the mempool.
-func TestHandleRequestedTransactionsNotFound(t *testing.T) {
-	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
-		var log = logger.RegisterSubSystem("PROT")
-		var spawn = panics.GoroutineWrapperFunc(log)
-		factory := consensus.NewFactory()
-		tc, teardown, err := factory.NewTestConsensus(consensusConfig, "TestHandleRequestedTransactionsNotFound")
-		if err != nil {
-			t.Fatalf("Error setting up test Consensus: %+v", err)
-		}
-		defer teardown(false)
-
-		sharedRequestedTransactions := flowcontext.NewSharedRequestedTransactions()
-		adapter, err := netadapter.NewNetAdapter(config.DefaultConfig())
-		if err != nil {
-			t.Fatalf("Failed to create a NetAdapter: %v", err)
-		}
-		domainInstance, err := domain.New(consensusConfig, mempool.DefaultConfig(&consensusConfig.Params), tc.Database())
-		if err != nil {
-			t.Fatalf("Failed to set up a domain Instance: %v", err)
-		}
-		context := &mocTransactionsRelayContext{
-			netAdapter:                  adapter,
-			domain:                      domainInstance,
-			sharedRequestedTransactions: sharedRequestedTransactions,
-		}
-		incomingRoute := router.NewRoute("incoming")
-		outgoingRoute := router.NewRoute("outgoing")
-		defer outgoingRoute.Close()
-
-		txID1 := externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01})
-		txID2 := externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02})
-		txIDs := []*externalapi.DomainTransactionID{txID1, txID2}
-		msg := appmessage.NewMsgRequestTransactions(txIDs)
-		err = incomingRoute.Enqueue(msg)
-		if err != nil {
-			t.Fatalf("Unexpected error from incomingRoute.Enqueue: %v", err)
-		}
-		// The goroutine is representing the peer's actions.
-		spawn("peerResponseToTheTransactionsMessages", func() {
-			for i, id := range txIDs {
-				msg, err := outgoingRoute.Dequeue()
-				if err != nil {
-					t.Fatalf("Dequeue: %s", err)
-				}
-				outMsg := msg.(*appmessage.MsgTransactionNotFound)
-				if txIDs[i].String() != outMsg.ID.String() {
-					t.Fatalf("TestHandleRelayedTransactions: expected equal txID: expected %s, but got %s", txIDs[i].String(), id.String())
-				}
-			}
-			// Closed the incomingRoute for stop the infinity loop.
-			incomingRoute.Close()
-		})
-
-		err = transactionrelay.HandleRequestedTransactions(context, incomingRoute, outgoingRoute)
-		// Make sure the error is due to the closed route.
-		if err == nil || !errors.Is(err, router.ErrRouteClosed) {
-			t.Fatalf("Unexpected error: expected: %v, got : %v", router.ErrRouteClosed, err)
-		}
-	})
-}

app/protocol/protocol.go

@@ -3,8 +3,7 @@ package protocol
 import (
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	"github.com/kaspanet/kaspad/app/protocol/flows/ready"
-	v4 "github.com/kaspanet/kaspad/app/protocol/flows/v4"
-	v5 "github.com/kaspanet/kaspad/app/protocol/flows/v5"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v5"
 	"sync"
 	"sync/atomic"
 
@@ -77,8 +76,6 @@ func (m *Manager) routerInitializer(router *routerpkg.Router, netConnection *net
 		var flows []*common.Flow
 		log.Infof("Registering p2p flows for peer %s for protocol version %d", peer, peer.ProtocolVersion())
 		switch peer.ProtocolVersion() {
-		case 4:
-			flows = v4.Register(m, router, errChan, &isStopping)
 		case 5:
 			flows = v5.Register(m, router, errChan, &isStopping)
 		default:

app/rpc/rpchandlers/get_block_template.go

@@ -4,6 +4,7 @@ import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/transactionhelper"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/kaspanet/kaspad/util"
@@ -16,7 +17,7 @@ func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, reque
 
 	payAddress, err := util.DecodeAddress(getBlockTemplateRequest.PayAddress, context.Config.ActiveNetParams.Prefix)
 	if err != nil {
-		errorMessage := &appmessage.GetBlockResponseMessage{}
+		errorMessage := &appmessage.GetBlockTemplateResponseMessage{}
 		errorMessage.Error = appmessage.RPCErrorf("Could not decode address: %s", err)
 		return errorMessage, nil
 	}
@@ -27,11 +28,17 @@ func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, reque
 	}
 
 	coinbaseData := &externalapi.DomainCoinbaseData{ScriptPublicKey: scriptPublicKey, ExtraData: []byte(version.Version() + "/" + getBlockTemplateRequest.ExtraData)}
-
 	templateBlock, err := context.Domain.MiningManager().GetBlockTemplate(coinbaseData)
 	if err != nil {
 		return nil, err
 	}
+
+	if uint64(len(templateBlock.Transactions[transactionhelper.CoinbaseTransactionIndex].Payload)) > context.Config.NetParams().MaxCoinbasePayloadLength {
+		errorMessage := &appmessage.GetBlockTemplateResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Coinbase payload is above max length (%d). Try to shorten the extra data.", context.Config.NetParams().MaxCoinbasePayloadLength)
+		return errorMessage, nil
+	}
+
 	rpcBlock := appmessage.DomainBlockToRPCBlock(templateBlock)
 
 	isSynced, err := context.ProtocolManager.ShouldMine()

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_block_template.go

@@ -38,20 +38,52 @@ func (x *KaspadMessage_GetBlockTemplateResponse) toAppMessage() (appmessage.Mess
 }
 
 func (x *KaspadMessage_GetBlockTemplateResponse) fromAppMessage(message *appmessage.GetBlockTemplateResponseMessage) error {
-	x.GetBlockTemplateResponse = &GetBlockTemplateResponseMessage{
-		Block:    &RpcBlock{},
-		IsSynced: message.IsSynced,
+	var err *RPCError
+	if message.Error != nil {
+		err = &RPCError{Message: message.Error.Message}
 	}
-	return x.GetBlockTemplateResponse.Block.fromAppMessage(message.Block)
+
+	var block *RpcBlock
+	if message.Block != nil {
+		protoBlock := &RpcBlock{}
+		err := protoBlock.fromAppMessage(message.Block)
+		if err != nil {
+			return err
+		}
+		block = protoBlock
+	}
+
+	x.GetBlockTemplateResponse = &GetBlockTemplateResponseMessage{
+		Block:    block,
+		IsSynced: message.IsSynced,
+		Error:    err,
+	}
+	return nil
 }
 
 func (x *GetBlockTemplateResponseMessage) toAppMessage() (appmessage.Message, error) {
 	if x == nil {
 		return nil, errors.Wrapf(errorNil, "GetBlockTemplateResponseMessage is nil")
 	}
-	msgBlock, err := x.Block.toAppMessage()
-	if err != nil {
-		return nil, err
+	var msgBlock *appmessage.RPCBlock
+	if x.Block != nil {
+		var err error
+		msgBlock, err = x.Block.toAppMessage()
+		if err != nil {
+			return nil, err
+		}
 	}
-	return appmessage.NewGetBlockTemplateResponseMessage(msgBlock, x.IsSynced), nil
+	var rpcError *appmessage.RPCError
+	if x.Error != nil {
+		var err error
+		rpcError, err = x.Error.toAppMessage()
+		if err != nil {
+			return nil, err
+		}
+	}
+	return &appmessage.GetBlockTemplateResponseMessage{
+		Block:    msgBlock,
+		IsSynced: x.IsSynced,
+		Error:    rpcError,
+	}, nil
 }

version/version.go

@@ -11,7 +11,7 @@ const validCharacters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrs
 const (
 	appMajor uint = 0
 	appMinor uint = 11
-	appPatch uint = 14
+	appPatch uint = 15
 )
 
 // appBuild is defined as a variable so it can be overridden during the build