Update changelog for v0.11.15 (#2006)

* Update changelog for v0.11.15

* Print full json of rule violating header

.github/workflows/deploy.yaml

@@ -19,16 +19,11 @@ 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
         with:
-          go-version: 1.16
+          go-version: 1.18
 
       - name: Build on Linux
         if: runner.os == 'Linux'

.github/workflows/race.yaml

@@ -22,7 +22,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v2
         with:
-          go-version: 1.16
+          go-version: 1.18
 
       - name: Set scheduled branch name
         shell: bash

.github/workflows/tests.yaml

@@ -33,7 +33,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v2
         with:
-          go-version: 1.16
+          go-version: 1.18
 
 
       # Source: https://github.com/actions/cache/blob/main/examples.md#go---modules
@@ -58,7 +58,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v2
         with:
-          go-version: 1.16
+          go-version: 1.18
 
       - name: Checkout
         uses: actions/checkout@v2
@@ -86,7 +86,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v2
         with:
-          go-version: 1.16
+          go-version: 1.18
 
       - name: Delete the stability tests from coverage
         run: rm -r stability-tests

README.md

@@ -15,7 +15,7 @@ Kaspa is an attempt at a proof-of-work cryptocurrency with instant confirmations
 
 ## Requirements
 
-Go 1.16 or later.
+Go 1.18 or later.
 
 ## Installation
 

app/appmessage/message.go

@@ -69,6 +69,10 @@ const (
 	CmdReady
 	CmdTrustedData
 	CmdBlockWithTrustedDataV4
+	CmdRequestNextPruningPointAndItsAnticoneBlocks
+	CmdRequestIBDChainBlockLocator
+	CmdIBDChainBlockLocator
+	CmdRequestAnticone
 
 	// rpc
 	CmdGetCurrentNetworkRequestMessage
@@ -152,6 +156,9 @@ const (
 	CmdVirtualDaaScoreChangedNotificationMessage
 	CmdGetBalancesByAddressesRequestMessage
 	CmdGetBalancesByAddressesResponseMessage
+	CmdNotifyNewBlockTemplateRequestMessage
+	CmdNotifyNewBlockTemplateResponseMessage
+	CmdNewBlockTemplateNotificationMessage
 )
 
 // ProtocolMessageCommandToString maps all MessageCommands to their string representation
@@ -195,6 +202,10 @@ var ProtocolMessageCommandToString = map[MessageCommand]string{
 	CmdReady:                               "Ready",
 	CmdTrustedData:                         "TrustedData",
 	CmdBlockWithTrustedDataV4:              "BlockWithTrustedDataV4",
+	CmdRequestNextPruningPointAndItsAnticoneBlocks: "RequestNextPruningPointAndItsAnticoneBlocks",
+	CmdRequestIBDChainBlockLocator:                 "RequestIBDChainBlockLocator",
+	CmdIBDChainBlockLocator:                        "IBDChainBlockLocator",
+	CmdRequestAnticone:                             "RequestAnticone",
 }
 
 // RPCMessageCommandToString maps all MessageCommands to their string representation
@@ -278,6 +289,9 @@ var RPCMessageCommandToString = map[MessageCommand]string{
 	CmdVirtualDaaScoreChangedNotificationMessage:                  "VirtualDaaScoreChangedNotification",
 	CmdGetBalancesByAddressesRequestMessage:                       "GetBalancesByAddressesRequest",
 	CmdGetBalancesByAddressesResponseMessage:                      "GetBalancesByAddressesResponse",
+	CmdNotifyNewBlockTemplateRequestMessage:                       "NotifyNewBlockTemplateRequest",
+	CmdNotifyNewBlockTemplateResponseMessage:                      "NotifyNewBlockTemplateResponse",
+	CmdNewBlockTemplateNotificationMessage:                        "NewBlockTemplateNotification",
 }
 
 // Message is an interface that describes a kaspa message. A type that

app/appmessage/p2p_msgibdchainblocklocator.go

@@ -0,0 +1,27 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MsgIBDChainBlockLocator implements the Message interface and represents a kaspa
+// locator message. It is used to find the blockLocator of a peer that is
+// syncing with you.
+type MsgIBDChainBlockLocator struct {
+	baseMessage
+	BlockLocatorHashes []*externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgIBDChainBlockLocator) Command() MessageCommand {
+	return CmdIBDChainBlockLocator
+}
+
+// NewMsgIBDChainBlockLocator returns a new kaspa locator message that conforms to
+// the Message interface. See MsgBlockLocator for details.
+func NewMsgIBDChainBlockLocator(locatorHashes []*externalapi.DomainHash) *MsgIBDChainBlockLocator {
+	return &MsgIBDChainBlockLocator{
+		BlockLocatorHashes: locatorHashes,
+	}
+}

app/appmessage/p2p_msgrequestanticone.go

@@ -0,0 +1,33 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MsgRequestAnticone implements the Message interface and represents a kaspa
+// RequestHeaders message. It is used to request the set past(ContextHash) \cap anticone(BlockHash)
+type MsgRequestAnticone struct {
+	baseMessage
+	BlockHash   *externalapi.DomainHash
+	ContextHash *externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestAnticone) Command() MessageCommand {
+	return CmdRequestAnticone
+}
+
+// NewMsgRequestAnticone returns a new kaspa RequestPastDiff message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgRequestAnticone(blockHash, contextHash *externalapi.DomainHash) *MsgRequestAnticone {
+	return &MsgRequestAnticone{
+		BlockHash:   blockHash,
+		ContextHash: contextHash,
+	}
+}

app/appmessage/p2p_msgrequestibdchainblocklocator.go

@@ -0,0 +1,31 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MsgRequestIBDChainBlockLocator implements the Message interface and represents a kaspa
+// IBDRequestChainBlockLocator message. It is used to request a block locator between low
+// and high hash.
+// The locator is returned via a locator message (MsgIBDChainBlockLocator).
+type MsgRequestIBDChainBlockLocator struct {
+	baseMessage
+	HighHash *externalapi.DomainHash
+	LowHash  *externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestIBDChainBlockLocator) Command() MessageCommand {
+	return CmdRequestIBDChainBlockLocator
+}
+
+// NewMsgIBDRequestChainBlockLocator returns a new IBDRequestChainBlockLocator message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgIBDRequestChainBlockLocator(highHash, lowHash *externalapi.DomainHash) *MsgRequestIBDChainBlockLocator {
+	return &MsgRequestIBDChainBlockLocator{
+		HighHash: highHash,
+		LowHash:  lowHash,
+	}
+}

app/appmessage/p2p_msgrequestnextpruningpointanditsanticoneblocks.go

@@ -0,0 +1,22 @@
+package appmessage
+
+// MsgRequestNextPruningPointAndItsAnticoneBlocks implements the Message interface and represents a kaspa
+// RequestNextPruningPointAndItsAnticoneBlocks message. It is used to notify the IBD syncer peer to send
+// more blocks from the pruning anticone.
+//
+// This message has no payload.
+type MsgRequestNextPruningPointAndItsAnticoneBlocks struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestNextPruningPointAndItsAnticoneBlocks) Command() MessageCommand {
+	return CmdRequestNextPruningPointAndItsAnticoneBlocks
+}
+
+// NewMsgRequestNextPruningPointAndItsAnticoneBlocks returns a new kaspa RequestNextPruningPointAndItsAnticoneBlocks message that conforms to the
+// Message interface.
+func NewMsgRequestNextPruningPointAndItsAnticoneBlocks() *MsgRequestNextPruningPointAndItsAnticoneBlocks {
+	return &MsgRequestNextPruningPointAndItsAnticoneBlocks{}
+}

app/appmessage/rpc_get_block_template.go

@@ -5,6 +5,7 @@ package appmessage
 type GetBlockTemplateRequestMessage struct {
 	baseMessage
 	PayAddress string
+	ExtraData  string
 }
 
 // Command returns the protocol command string for the message
@@ -13,9 +14,10 @@ func (msg *GetBlockTemplateRequestMessage) Command() MessageCommand {
 }
 
 // NewGetBlockTemplateRequestMessage returns a instance of the message
-func NewGetBlockTemplateRequestMessage(payAddress string) *GetBlockTemplateRequestMessage {
+func NewGetBlockTemplateRequestMessage(payAddress, extraData string) *GetBlockTemplateRequestMessage {
 	return &GetBlockTemplateRequestMessage{
 		PayAddress: payAddress,
+		ExtraData:  extraData,
 	}
 }
 

app/appmessage/rpc_notify_new_block_template.go

@@ -0,0 +1,50 @@
+package appmessage
+
+// NotifyNewBlockTemplateRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyNewBlockTemplateRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyNewBlockTemplateRequestMessage) Command() MessageCommand {
+	return CmdNotifyNewBlockTemplateRequestMessage
+}
+
+// NewNotifyNewBlockTemplateRequestMessage returns an instance of the message
+func NewNotifyNewBlockTemplateRequestMessage() *NotifyNewBlockTemplateRequestMessage {
+	return &NotifyNewBlockTemplateRequestMessage{}
+}
+
+// NotifyNewBlockTemplateResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyNewBlockTemplateResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyNewBlockTemplateResponseMessage) Command() MessageCommand {
+	return CmdNotifyNewBlockTemplateResponseMessage
+}
+
+// NewNotifyNewBlockTemplateResponseMessage returns an instance of the message
+func NewNotifyNewBlockTemplateResponseMessage() *NotifyNewBlockTemplateResponseMessage {
+	return &NotifyNewBlockTemplateResponseMessage{}
+}
+
+// NewBlockTemplateNotificationMessage is an appmessage corresponding to
+// its respective RPC message
+type NewBlockTemplateNotificationMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *NewBlockTemplateNotificationMessage) Command() MessageCommand {
+	return CmdNewBlockTemplateNotificationMessage
+}
+
+// NewNewBlockTemplateNotificationMessage returns an instance of the message
+func NewNewBlockTemplateNotificationMessage() *NewBlockTemplateNotificationMessage {
+	return &NewBlockTemplateNotificationMessage{}
+}

app/component_manager.go

@@ -153,6 +153,7 @@ func setupRPC(
 		shutDownChan,
 	)
 	protocolManager.SetOnVirtualChange(rpcManager.NotifyVirtualChange)
+	protocolManager.SetOnNewBlockTemplateHandler(rpcManager.NotifyNewBlockTemplate)
 	protocolManager.SetOnBlockAddedToDAGHandler(rpcManager.NotifyBlockAddedToDAG)
 	protocolManager.SetOnPruningPointUTXOSetOverrideHandler(rpcManager.NotifyPruningPointUTXOSetOverride)
 

app/protocol/flowcontext/blocks.go

@@ -20,8 +20,8 @@ func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock,
 	virtualChangeSet *externalapi.VirtualChangeSet) error {
 
 	hash := consensushashing.BlockHash(block)
-	log.Debugf("OnNewBlock start for block %s", hash)
-	defer log.Debugf("OnNewBlock end for block %s", hash)
+	log.Tracef("OnNewBlock start for block %s", hash)
+	defer log.Tracef("OnNewBlock end for block %s", hash)
 
 	unorphaningResults, err := f.UnorphanBlocks(block)
 	if err != nil {
@@ -68,6 +68,15 @@ func (f *FlowContext) OnVirtualChange(virtualChangeSet *externalapi.VirtualChang
 	return nil
 }
 
+// OnNewBlockTemplate calls the handler function whenever a new block template is available for miners.
+func (f *FlowContext) OnNewBlockTemplate() error {
+	if f.onNewBlockTemplateHandler != nil {
+		return f.onNewBlockTemplateHandler()
+	}
+
+	return nil
+}
+
 // OnPruningPointUTXOSetOverride calls the handler function whenever the UTXO set
 // resets due to pruning point change via IBD.
 func (f *FlowContext) OnPruningPointUTXOSetOverride() error {
@@ -125,6 +134,10 @@ func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
 		}
 		return err
 	}
+	err = f.OnNewBlockTemplate()
+	if err != nil {
+		return err
+	}
 	err = f.OnNewBlock(block, virtualChangeSet)
 	if err != nil {
 		return err
@@ -150,7 +163,7 @@ func (f *FlowContext) TrySetIBDRunning(ibdPeer *peerpkg.Peer) bool {
 		return false
 	}
 	f.ibdPeer = ibdPeer
-	log.Infof("IBD started")
+	log.Infof("IBD started with peer %s", ibdPeer)
 
 	return true
 }

app/protocol/flowcontext/errors.go

@@ -2,6 +2,7 @@ package flowcontext
 
 import (
 	"errors"
+	"strings"
 	"sync/atomic"
 
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
@@ -9,6 +10,11 @@ import (
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 )
 
+var (
+	// ErrPingTimeout signifies that a ping operation timed out.
+	ErrPingTimeout = protocolerrors.New(false, "timeout expired on ping")
+)
+
 // HandleError handles an error from a flow,
 // It sends the error to errChan if isStopping == 0 and increments isStopping
 //
@@ -21,8 +27,15 @@ func (*FlowContext) HandleError(err error, flowName string, isStopping *uint32,
 		if protocolErr := (protocolerrors.ProtocolError{}); !errors.As(err, &protocolErr) {
 			panic(err)
 		}
-
-		log.Errorf("error from %s: %s", flowName, err)
+		if errors.Is(err, ErrPingTimeout) {
+			// Avoid printing the call stack on ping timeouts, since users get panicked and this case is not interesting
+			log.Errorf("error from %s: %s", flowName, err)
+		} else {
+			// Explain to the user that this is not a panic, but only a protocol error with a specific peer
+			logFrame := strings.Repeat("=", 52)
+			log.Errorf("Non-critical peer protocol error from %s, printing the full stack for debug purposes: \n%s\n%+v \n%s",
+				flowName, logFrame, err, logFrame)
+		}
 	}
 
 	if atomic.AddUint32(isStopping, 1) == 1 {

app/protocol/flowcontext/flow_context.go

@@ -25,6 +25,9 @@ type OnBlockAddedToDAGHandler func(block *externalapi.DomainBlock, virtualChange
 // OnVirtualChangeHandler is a handler function that's triggered when the virtual changes
 type OnVirtualChangeHandler func(virtualChangeSet *externalapi.VirtualChangeSet) error
 
+// OnNewBlockTemplateHandler is a handler function that's triggered when a new block template is available
+type OnNewBlockTemplateHandler func() error
+
 // OnPruningPointUTXOSetOverrideHandler is a handle function that's triggered whenever the UTXO set
 // resets due to pruning point change via IBD.
 type OnPruningPointUTXOSetOverrideHandler func() error
@@ -46,11 +49,13 @@ type FlowContext struct {
 
 	onVirtualChangeHandler               OnVirtualChangeHandler
 	onBlockAddedToDAGHandler             OnBlockAddedToDAGHandler
+	onNewBlockTemplateHandler            OnNewBlockTemplateHandler
 	onPruningPointUTXOSetOverrideHandler OnPruningPointUTXOSetOverrideHandler
 	onTransactionAddedToMempoolHandler   OnTransactionAddedToMempoolHandler
 
-	lastRebroadcastTime         time.Time
-	sharedRequestedTransactions *SharedRequestedTransactions
+	expectedDAAWindowDurationInMilliseconds int64
+	lastRebroadcastTime                     time.Time
+	sharedRequestedTransactions             *SharedRequestedTransactions
 
 	sharedRequestedBlocks *SharedRequestedBlocks
 
@@ -88,6 +93,8 @@ func New(cfg *config.Config, domain domain.Domain, addressManager *addressmanage
 		transactionIDsToPropagate:        []*externalapi.DomainTransactionID{},
 		lastTransactionIDPropagationTime: time.Now(),
 		shutdownChan:                     make(chan struct{}),
+		expectedDAAWindowDurationInMilliseconds: cfg.NetParams().TargetTimePerBlock.Milliseconds() *
+			int64(cfg.NetParams().DifficultyAdjustmentWindowSize),
 	}
 }
 
@@ -112,6 +119,11 @@ func (f *FlowContext) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler OnBlo
 	f.onBlockAddedToDAGHandler = onBlockAddedToDAGHandler
 }
 
+// SetOnNewBlockTemplateHandler sets the onNewBlockTemplateHandler handler
+func (f *FlowContext) SetOnNewBlockTemplateHandler(onNewBlockTemplateHandler OnNewBlockTemplateHandler) {
+	f.onNewBlockTemplateHandler = onNewBlockTemplateHandler
+}
+
 // SetOnPruningPointUTXOSetOverrideHandler sets the onPruningPointUTXOSetOverrideHandler handler
 func (f *FlowContext) SetOnPruningPointUTXOSetOverrideHandler(onPruningPointUTXOSetOverrideHandler OnPruningPointUTXOSetOverrideHandler) {
 	f.onPruningPointUTXOSetOverrideHandler = onPruningPointUTXOSetOverrideHandler

app/protocol/flowcontext/should_mine.go

@@ -2,21 +2,12 @@ package flowcontext
 
 import "github.com/kaspanet/kaspad/util/mstime"
 
-const (
-	maxSelectedParentTimeDiffToAllowMiningInMilliSeconds = 60 * 60 * 1000 // 1 Hour
-)
-
-// ShouldMine returns whether it's ok to use block template from this node
-// for mining purposes.
-func (f *FlowContext) ShouldMine() (bool, error) {
+// IsNearlySynced returns whether this node is considered synced or close to being synced. This info
+// is used to determine if it's ok to use a block template from this node for mining purposes.
+func (f *FlowContext) IsNearlySynced() (bool, error) {
 	peers := f.Peers()
 	if len(peers) == 0 {
-		log.Debugf("The node is not connected, so ShouldMine returns false")
-		return false, nil
-	}
-
-	if f.IsIBDRunning() {
-		log.Debugf("IBD is running, so ShouldMine returns false")
+		log.Debugf("The node is not connected to peers, so IsNearlySynced returns false")
 		return false, nil
 	}
 
@@ -35,13 +26,15 @@ func (f *FlowContext) ShouldMine() (bool, error) {
 	}
 
 	now := mstime.Now().UnixMilliseconds()
-	if now-virtualSelectedParentHeader.TimeInMilliseconds() < maxSelectedParentTimeDiffToAllowMiningInMilliSeconds {
-		log.Debugf("The selected tip timestamp is recent (%d), so ShouldMine returns true",
+	// As a heuristic, we allow the node to mine if he is likely to be within the current DAA window of fully synced nodes.
+	// Such blocks contribute to security by maintaining the current difficulty despite possibly being slightly out of sync.
+	if now-virtualSelectedParentHeader.TimeInMilliseconds() < f.expectedDAAWindowDurationInMilliseconds {
+		log.Debugf("The selected tip timestamp is recent (%d), so IsNearlySynced returns true",
 			virtualSelectedParentHeader.TimeInMilliseconds())
 		return true, nil
 	}
 
-	log.Debugf("The selected tip timestamp is old (%d), so ShouldMine returns false",
+	log.Debugf("The selected tip timestamp is old (%d), so IsNearlySynced returns false",
 		virtualSelectedParentHeader.TimeInMilliseconds())
 	return false, nil
 }

app/protocol/flows/handshake/receiveversion.go

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

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

@@ -0,0 +1,16 @@
+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 router.DefaultMaxMessages (%d)",
+			ibdBatchSize, router.DefaultMaxMessages)
+	}
+}

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

@@ -33,7 +33,7 @@ func HandleIBDBlockRequests(context HandleIBDBlockRequestsContext, incomingRoute
 				return err
 			}
 			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
-				return protocolerrors.Errorf(true, "block %s not found", hash)
+				return protocolerrors.Errorf(true, "block %s not found (v5)", hash)
 			}
 			block, err := context.Domain().Consensus().GetBlock(hash)
 			if err != nil {

app/protocol/flows/v5/blockrelay/handle_ibd_request_chain_block_locator.go

@@ -0,0 +1,85 @@
+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"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/pkg/errors"
+)
+
+// RequestIBDChainBlockLocatorContext is the interface for the context needed for the HandleRequestBlockLocator flow.
+type RequestIBDChainBlockLocatorContext interface {
+	Domain() domain.Domain
+}
+
+type handleRequestIBDChainBlockLocatorFlow struct {
+	RequestIBDChainBlockLocatorContext
+	incomingRoute, outgoingRoute *router.Route
+}
+
+// HandleRequestIBDChainBlockLocator handles getBlockLocator messages
+func HandleRequestIBDChainBlockLocator(context RequestIBDChainBlockLocatorContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route) error {
+
+	flow := &handleRequestIBDChainBlockLocatorFlow{
+		RequestIBDChainBlockLocatorContext: context,
+		incomingRoute:                      incomingRoute,
+		outgoingRoute:                      outgoingRoute,
+	}
+	return flow.start()
+}
+
+func (flow *handleRequestIBDChainBlockLocatorFlow) start() error {
+	for {
+		highHash, lowHash, err := flow.receiveRequestIBDChainBlockLocator()
+		if err != nil {
+			return err
+		}
+		log.Debugf("Received getIBDChainBlockLocator with highHash: %s, lowHash: %s", highHash, lowHash)
+
+		var locator externalapi.BlockLocator
+		if highHash == nil || lowHash == nil {
+			locator, err = flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
+		} else {
+			locator, err = flow.Domain().Consensus().CreateHeadersSelectedChainBlockLocator(lowHash, highHash)
+			if errors.Is(model.ErrBlockNotInSelectedParentChain, err) {
+				// The chain has been modified, signal it by sending an empty locator
+				locator, err = externalapi.BlockLocator{}, nil
+			}
+		}
+
+		if err != nil {
+			log.Debugf("Received error from CreateHeadersSelectedChainBlockLocator: %s", err)
+			return protocolerrors.Errorf(true, "couldn't build a block "+
+				"locator between %s and %s", lowHash, highHash)
+		}
+
+		err = flow.sendIBDChainBlockLocator(locator)
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (flow *handleRequestIBDChainBlockLocatorFlow) receiveRequestIBDChainBlockLocator() (highHash, lowHash *externalapi.DomainHash, err error) {
+
+	message, err := flow.incomingRoute.Dequeue()
+	if err != nil {
+		return nil, nil, err
+	}
+	msgGetBlockLocator := message.(*appmessage.MsgRequestIBDChainBlockLocator)
+
+	return msgGetBlockLocator.HighHash, msgGetBlockLocator.LowHash, nil
+}
+
+func (flow *handleRequestIBDChainBlockLocatorFlow) sendIBDChainBlockLocator(locator externalapi.BlockLocator) error {
+	msgIBDChainBlockLocator := appmessage.NewMsgIBDChainBlockLocator(locator)
+	err := flow.outgoingRoute.Enqueue(msgIBDChainBlockLocator)
+	if err != nil {
+		return err
+	}
+	return nil
+}

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

@@ -118,7 +118,7 @@ func HandlePruningPointAndItsAnticoneRequests(context PruningPointAndItsAnticone
 				return err
 			}
 
-			for _, blockHash := range pointAndItsAnticone {
+			for i, blockHash := range pointAndItsAnticone {
 				block, err := context.Domain().Consensus().GetBlock(blockHash)
 				if err != nil {
 					return err
@@ -128,6 +128,19 @@ func HandlePruningPointAndItsAnticoneRequests(context PruningPointAndItsAnticone
 				if err != nil {
 					return err
 				}
+
+				if (i+1)%ibdBatchSize == 0 {
+					// No timeout here, as we don't care if the syncee takes its time computing,
+					// since it only blocks this dedicated flow
+					message, err := incomingRoute.Dequeue()
+					if err != nil {
+						return err
+					}
+					if _, ok := message.(*appmessage.MsgRequestNextPruningPointAndItsAnticoneBlocks); !ok {
+						return protocolerrors.Errorf(true, "received unexpected message type. "+
+							"expected: %s, got: %s", appmessage.CmdRequestNextPruningPointAndItsAnticoneBlocks, message.Command())
+					}
+				}
 			}
 
 			err = outgoingRoute.Enqueue(appmessage.NewMsgDoneBlocksWithTrustedData())

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

@@ -10,6 +10,7 @@ import (
 	"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"
@@ -26,6 +27,7 @@ type RelayInvsContext interface {
 	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
@@ -34,6 +36,7 @@ type RelayInvsContext interface {
 	IsOrphan(blockHash *externalapi.DomainHash) bool
 	IsIBDRunning() bool
 	IsRecoverableError(err error) bool
+	IsNearlySynced() (bool, error)
 }
 
 type handleRelayInvsFlow struct {
@@ -104,10 +107,16 @@ func (flow *handleRelayInvsFlow) start() error {
 			continue
 		}
 
-		// Block relay is disabled during IBD
+		// Block relay is disabled if the node is already during IBD AND considered out of sync
 		if flow.IsIBDRunning() {
-			log.Debugf("Got block %s while in IBD. continuing...", inv.Hash)
-			continue
+			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)
@@ -131,6 +140,10 @@ func (flow *handleRelayInvsFlow) start() error {
 		}
 
 		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) {
@@ -153,11 +166,42 @@ func (flow *handleRelayInvsFlow) start() error {
 			continue
 		}
 
-		log.Debugf("Relaying block %s", inv.Hash)
-		err = flow.relayBlock(block)
+		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 {
@@ -258,7 +302,10 @@ func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([
 		if errors.As(err, missingParentsError) {
 			return missingParentsError.MissingParentHashes, nil, nil
 		}
-		log.Warnf("Rejected block %s from %s: %s", blockHash, flow.peer, err)
+		// 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
@@ -369,6 +416,10 @@ func (flow *handleRelayInvsFlow) AddOrphanRootsToQueue(orphan *externalapi.Domai
 			"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))

app/protocol/flows/v5/blockrelay/handle_request_anticone.go

@@ -0,0 +1,95 @@
+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/config"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"sort"
+)
+
+// RequestAnticoneContext is the interface for the context needed for the HandleRequestHeaders flow.
+type RequestAnticoneContext interface {
+	Domain() domain.Domain
+	Config() *config.Config
+}
+
+type handleRequestAnticoneFlow struct {
+	RequestAnticoneContext
+	incomingRoute, outgoingRoute *router.Route
+	peer                         *peer.Peer
+}
+
+// HandleRequestAnticone handles RequestAnticone messages
+func HandleRequestAnticone(context RequestAnticoneContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route, peer *peer.Peer) error {
+
+	flow := &handleRequestAnticoneFlow{
+		RequestAnticoneContext: context,
+		incomingRoute:          incomingRoute,
+		outgoingRoute:          outgoingRoute,
+		peer:                   peer,
+	}
+	return flow.start()
+}
+
+func (flow *handleRequestAnticoneFlow) start() error {
+	for {
+		blockHash, contextHash, err := receiveRequestAnticone(flow.incomingRoute)
+		if err != nil {
+			return err
+		}
+		log.Debugf("Received requestAnticone with blockHash: %s, contextHash: %s", blockHash, contextHash)
+		log.Debugf("Getting past(%s) cap anticone(%s) for peer %s", contextHash, blockHash, flow.peer)
+
+		// GetAnticone is expected to be called by the syncee for getting the anticone of the header selected tip
+		// intersected by past of relayed block, and is thus expected to be bounded by mergeset limit since
+		// we relay blocks only if they enter virtual's mergeset. We add 2 for a small margin error.
+		blockHashes, err := flow.Domain().Consensus().GetAnticone(blockHash, contextHash,
+			flow.Config().ActiveNetParams.MergeSetSizeLimit+2)
+		if err != nil {
+			return protocolerrors.Wrap(true, err, "Failed querying anticone")
+		}
+		log.Debugf("Got %d header hashes in past(%s) cap anticone(%s)", len(blockHashes), contextHash, blockHash)
+
+		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)
+		}
+
+		// We sort the headers in bottom-up topological order before sending
+		sort.Slice(blockHeaders, func(i, j int) bool {
+			return blockHeaders[i].BlueWork.Cmp(blockHeaders[j].BlueWork) < 0
+		})
+
+		blockHeadersMessage := appmessage.NewBlockHeadersMessage(blockHeaders)
+		err = flow.outgoingRoute.Enqueue(blockHeadersMessage)
+		if err != nil {
+			return err
+		}
+
+		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgDoneHeaders())
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func receiveRequestAnticone(incomingRoute *router.Route) (blockHash *externalapi.DomainHash,
+	contextHash *externalapi.DomainHash, err error) {
+
+	message, err := incomingRoute.Dequeue()
+	if err != nil {
+		return nil, nil, err
+	}
+	msgRequestAnticone := message.(*appmessage.MsgRequestAnticone)
+
+	return msgRequestAnticone.BlockHash, msgRequestAnticone.ContextHash, nil
+}

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

@@ -10,7 +10,9 @@ import (
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
-const ibdBatchSize = router.DefaultMaxMessages
+// 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 = 99
 
 // RequestHeadersContext is the interface for the context needed for the HandleRequestHeaders flow.
 type RequestHeadersContext interface {
@@ -42,7 +44,16 @@ func (flow *handleRequestHeadersFlow) start() error {
 		if err != nil {
 			return err
 		}
-		log.Debugf("Recieved requestHeaders with lowHash: %s, highHash: %s", lowHash, highHash)
+		log.Debugf("Received requestHeaders with lowHash: %s, highHash: %s", lowHash, highHash)
+
+		isLowSelectedAncestorOfHigh, err := flow.Domain().Consensus().IsInSelectedParentChainOf(lowHash, highHash)
+		if err != nil {
+			return err
+		}
+		if !isLowSelectedAncestorOfHigh {
+			return protocolerrors.Errorf(true, "Expected %s to be on the selected chain of %s",
+				lowHash, highHash)
+		}
 
 		for !lowHash.Equal(highHash) {
 			log.Debugf("Getting block headers between %s and %s to %s", lowHash, highHash, flow.peer)

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

@@ -6,16 +6,13 @@ import (
 	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"
 )
 
@@ -25,6 +22,7 @@ type IBDContext interface {
 	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
@@ -66,29 +64,6 @@ func (flow *handleIBDFlow) start() error {
 }
 
 func (flow *handleIBDFlow) runIBDIfNotRunning(block *externalapi.DomainBlock) error {
-	highHash := consensushashing.BlockHash(block)
-
-	// Temp code to avoid IBD from lagging nodes publishing their side-chain
-	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
-	if err == nil {
-		virtualSelectedParentHeader, err := flow.Domain().Consensus().GetBlockHeader(virtualSelectedParent)
-		if err == nil {
-			if virtualSelectedParentHeader.DAAScore() > block.Header.DAAScore()+2641 {
-				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 because it is coming from " +
-						"a deep (%d DAA score depth) side-chain which has much 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")
@@ -101,16 +76,19 @@ func (flow *handleIBDFlow) runIBDIfNotRunning(block *externalapi.DomainBlock) er
 		flow.logIBDFinished(isFinishedSuccessfully)
 	}()
 
-	log.Criticalf("IBD started with peer %s and highHash %s", flow.peer, highHash)
-	log.Criticalf("Syncing blocks up to %s", highHash)
-	log.Criticalf("Trying to find highest shared chain block with peer %s with high hash %s", flow.peer, highHash)
-	highestSharedBlockHash, highestSharedBlockFound, err := flow.findHighestSharedBlockHash(highHash)
+	relayBlockHash := consensushashing.BlockHash(block)
+
+	log.Debugf("IBD started with peer %s and relayBlockHash %s", flow.peer, relayBlockHash)
+	log.Debugf("Syncing blocks up to %s", relayBlockHash)
+	log.Debugf("Trying to find highest known syncer chain block from peer %s with relay hash %s", flow.peer, relayBlockHash)
+
+	syncerHeaderSelectedTipHash, highestKnownSyncerChainHash, err := flow.negotiateMissingSyncerChainSegment()
 	if err != nil {
 		return err
 	}
-	log.Criticalf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
 
-	shouldDownloadHeadersProof, shouldSync, err := flow.shouldSyncAndShouldDownloadHeadersProof(block, highestSharedBlockFound)
+	shouldDownloadHeadersProof, shouldSync, err := flow.shouldSyncAndShouldDownloadHeadersProof(
+		block, highestKnownSyncerChainHash)
 	if err != nil {
 		return err
 	}
@@ -121,7 +99,7 @@ func (flow *handleIBDFlow) runIBDIfNotRunning(block *externalapi.DomainBlock) er
 
 	if shouldDownloadHeadersProof {
 		log.Infof("Starting IBD with headers proof")
-		err := flow.ibdWithHeadersProof(highHash, block.Header.DAAScore())
+		err := flow.ibdWithHeadersProof(syncerHeaderSelectedTipHash, relayBlockHash, block.Header.DAAScore())
 		if err != nil {
 			return err
 		}
@@ -134,27 +112,162 @@ func (flow *handleIBDFlow) runIBDIfNotRunning(block *externalapi.DomainBlock) er
 
 			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)
+					"to the recent pruning point before normal operation can resume.", relayBlockHash)
 				return nil
 			}
 		}
 
-		err = flow.syncPruningPointFutureHeaders(flow.Domain().Consensus(), highestSharedBlockHash, highHash, block.Header.DAAScore())
+		err = flow.syncPruningPointFutureHeaders(
+			flow.Domain().Consensus(),
+			syncerHeaderSelectedTipHash, highestKnownSyncerChainHash, relayBlockHash, block.Header.DAAScore())
 		if err != nil {
 			return err
 		}
 	}
 
-	err = flow.syncMissingBlockBodies(highHash)
+	// We start by syncing missing bodies over the syncer selected chain
+	err = flow.syncMissingBlockBodies(syncerHeaderSelectedTipHash)
 	if err != nil {
 		return err
 	}
+	relayBlockInfo, err := flow.Domain().Consensus().GetBlockInfo(relayBlockHash)
+	if err != nil {
+		return err
+	}
+	// Relay block might be in the anticone of syncer selected tip, thus
+	// check his chain for missing bodies as well.
+	// Note: this operation can be slightly optimized to avoid the full chain search since relay block
+	// is in syncer virtual mergeset which has bounded size.
+	if relayBlockInfo.BlockStatus == externalapi.StatusHeaderOnly {
+		err = flow.syncMissingBlockBodies(relayBlockHash)
+		if err != nil {
+			return err
+		}
+	}
 
-	log.Debugf("Finished syncing blocks up to %s", highHash)
+	log.Debugf("Finished syncing blocks up to %s", relayBlockHash)
 	isFinishedSuccessfully = true
 	return nil
 }
 
+func (flow *handleIBDFlow) negotiateMissingSyncerChainSegment() (*externalapi.DomainHash, *externalapi.DomainHash, error) {
+	/*
+		Algorithm:
+			Request full selected chain block locator from syncer
+			Find the highest block which we know
+			Repeat the locator step over the new range until finding max(past(syncee) \cap chain(syncer))
+	*/
+
+	// Empty hashes indicate that the full chain is queried
+	locatorHashes, err := flow.getSyncerChainBlockLocator(nil, nil, common.DefaultTimeout)
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(locatorHashes) == 0 {
+		return nil, nil, protocolerrors.Errorf(true, "Expecting initial syncer chain block locator "+
+			"to contain at least one element")
+	}
+	log.Debugf("IBD chain negotiation with peer %s started and received %d hashes (%s, %s)", flow.peer,
+		len(locatorHashes), locatorHashes[0], locatorHashes[len(locatorHashes)-1])
+	syncerHeaderSelectedTipHash := locatorHashes[0]
+	var highestKnownSyncerChainHash *externalapi.DomainHash
+	chainNegotiationRestartCounter := 0
+	chainNegotiationZoomCounts := 0
+	initialLocatorLen := len(locatorHashes)
+	for {
+		var lowestUnknownSyncerChainHash, currentHighestKnownSyncerChainHash *externalapi.DomainHash
+		for _, syncerChainHash := range locatorHashes {
+			info, err := flow.Domain().Consensus().GetBlockInfo(syncerChainHash)
+			if err != nil {
+				return nil, nil, err
+			}
+			if info.Exists {
+				currentHighestKnownSyncerChainHash = syncerChainHash
+				break
+			}
+			lowestUnknownSyncerChainHash = syncerChainHash
+		}
+		// No unknown blocks, break. Note this can only happen in the first iteration
+		if lowestUnknownSyncerChainHash == nil {
+			highestKnownSyncerChainHash = currentHighestKnownSyncerChainHash
+			break
+		}
+		// No shared block, break
+		if currentHighestKnownSyncerChainHash == nil {
+			highestKnownSyncerChainHash = nil
+			break
+		}
+		// No point in zooming further
+		if len(locatorHashes) == 1 {
+			highestKnownSyncerChainHash = currentHighestKnownSyncerChainHash
+			break
+		}
+		// Zoom in
+		locatorHashes, err = flow.getSyncerChainBlockLocator(
+			lowestUnknownSyncerChainHash,
+			currentHighestKnownSyncerChainHash, time.Second*10)
+		if err != nil {
+			return nil, nil, err
+		}
+		if len(locatorHashes) > 0 {
+			if !locatorHashes[0].Equal(lowestUnknownSyncerChainHash) ||
+				!locatorHashes[len(locatorHashes)-1].Equal(currentHighestKnownSyncerChainHash) {
+				return nil, nil, protocolerrors.Errorf(true, "Expecting the high and low "+
+					"hashes to match the locator bounds")
+			}
+
+			chainNegotiationZoomCounts++
+			log.Debugf("IBD chain negotiation with peer %s zoomed in (%d) and received %d hashes (%s, %s)", flow.peer,
+				chainNegotiationZoomCounts, len(locatorHashes), locatorHashes[0], locatorHashes[len(locatorHashes)-1])
+
+			if len(locatorHashes) == 2 {
+				// We found our search target
+				highestKnownSyncerChainHash = currentHighestKnownSyncerChainHash
+				break
+			}
+
+			if chainNegotiationZoomCounts > initialLocatorLen*2 {
+				// Since the zoom-in always queries two consecutive entries in the previous locator, it is
+				// expected to decrease in size at least every two iterations
+				return nil, nil, protocolerrors.Errorf(true,
+					"IBD chain negotiation: Number of zoom-in steps %d exceeded the upper bound of 2*%d",
+					chainNegotiationZoomCounts, initialLocatorLen)
+			}
+
+		} else { // Empty locator signals a restart due to chain changes
+			chainNegotiationZoomCounts = 0
+			chainNegotiationRestartCounter++
+			if chainNegotiationRestartCounter > 32 {
+				return nil, nil, protocolerrors.Errorf(false,
+					"IBD chain negotiation with syncer %s exceeded restart limit %d", flow.peer, chainNegotiationRestartCounter)
+			}
+			log.Warnf("IBD chain negotiation with syncer %s restarted %d times", flow.peer, chainNegotiationRestartCounter)
+
+			// An empty locator signals that the syncer chain was modified and no longer contains one of
+			// the queried hashes, so we restart the search. We use a shorter timeout here to avoid a timeout attack
+			locatorHashes, err = flow.getSyncerChainBlockLocator(nil, nil, time.Second*10)
+			if err != nil {
+				return nil, nil, err
+			}
+			if len(locatorHashes) == 0 {
+				return nil, nil, protocolerrors.Errorf(true, "Expecting initial syncer chain block locator "+
+					"to contain at least one element")
+			}
+			log.Infof("IBD chain negotiation with peer %s restarted (%d) and received %d hashes (%s, %s)", flow.peer,
+				chainNegotiationRestartCounter, len(locatorHashes), locatorHashes[0], locatorHashes[len(locatorHashes)-1])
+
+			initialLocatorLen = len(locatorHashes)
+			// Reset syncer's header selected tip
+			syncerHeaderSelectedTipHash = locatorHashes[0]
+		}
+	}
+
+	log.Debugf("Found highest known syncer chain block %s from peer %s",
+		highestKnownSyncerChainHash, flow.peer)
+
+	return syncerHeaderSelectedTipHash, highestKnownSyncerChainHash, nil
+}
+
 func (flow *handleIBDFlow) isGenesisVirtualSelectedParent() (bool, error) {
 	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
 	if err != nil {
@@ -169,141 +282,57 @@ func (flow *handleIBDFlow) logIBDFinished(isFinishedSuccessfully bool) {
 	if !isFinishedSuccessfully {
 		successString = "(interrupted)"
 	}
-	log.Infof("IBD finished %s", successString)
+	log.Infof("IBD with peer %s finished %s", flow.peer, 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) {
+func (flow *handleIBDFlow) getSyncerChainBlockLocator(
+	highHash, lowHash *externalapi.DomainHash, timeout time.Duration) ([]*externalapi.DomainHash, error) {
 
-	log.Debugf("Sending a blockLocator to %s between pruning point and headers selected tip", flow.peer)
-	blockLocator, err := flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
+	requestIbdChainBlockLocatorMessage := appmessage.NewMsgIBDRequestChainBlockLocator(highHash, lowHash)
+	err := flow.outgoingRoute.Enqueue(requestIbdChainBlockLocatorMessage)
 	if err != nil {
-		return nil, false, err
+		return nil, 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)
+	message, err := flow.incomingRoute.DequeueWithTimeout(timeout)
 	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
+		return nil, 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
+	case *appmessage.MsgIBDChainBlockLocator:
+		if len(message.BlockLocatorHashes) > 64 {
+			return nil, protocolerrors.Errorf(true,
+				"Got block locator of size %d>64 while expecting locator to have size "+
+					"which is logarithmic in DAG size (which should never exceed 2^64)",
+				len(message.BlockLocatorHashes))
+		}
+		return message.BlockLocatorHashes, nil
 	default:
-		return nil, false, protocolerrors.Errorf(true, "received unexpected message type. "+
-			"expected: %s, got: %s", appmessage.CmdIBDBlockLocatorHighestHash, message.Command())
+		return nil, protocolerrors.Errorf(true, "received unexpected message type. "+
+			"expected: %s, got: %s", appmessage.CmdIBDChainBlockLocator, message.Command())
 	}
 }
 
-func (flow *handleIBDFlow) syncPruningPointFutureHeaders(consensus externalapi.Consensus, highestSharedBlockHash *externalapi.DomainHash,
-	highHash *externalapi.DomainHash, highBlockDAAScore uint64) error {
+func (flow *handleIBDFlow) syncPruningPointFutureHeaders(consensus externalapi.Consensus,
+	syncerHeaderSelectedTipHash, highestKnownSyncerChainHash, relayBlockHash *externalapi.DomainHash,
+	highBlockDAAScoreHint uint64) error {
 
 	log.Infof("Downloading headers from %s", flow.peer)
 
-	err := flow.sendRequestHeaders(highestSharedBlockHash, highHash)
+	if highestKnownSyncerChainHash.Equal(syncerHeaderSelectedTipHash) {
+		// No need to get syncer selected tip headers, so sync relay past and return
+		return flow.syncMissingRelayPast(consensus, syncerHeaderSelectedTipHash, relayBlockHash)
+	}
+
+	err := flow.sendRequestHeaders(highestKnownSyncerChainHash, syncerHeaderSelectedTipHash)
 	if err != nil {
 		return err
 	}
 
-	highestSharedBlockHeader, err := consensus.GetBlockHeader(highestSharedBlockHash)
+	highestSharedBlockHeader, err := consensus.GetBlockHeader(highestKnownSyncerChainHash)
 	if err != nil {
 		return err
 	}
-	progressReporter := newIBDProgressReporter(highestSharedBlockHeader.DAAScore(), highBlockDAAScore, "block headers")
+	progressReporter := newIBDProgressReporter(highestSharedBlockHeader.DAAScore(), highBlockDAAScoreHint, "block headers")
 
 	// Keep a short queue of BlockHeadersMessages so that there's
 	// never a moment when the node is not validating and inserting
@@ -321,6 +350,11 @@ func (flow *handleIBDFlow) syncPruningPointFutureHeaders(consensus externalapi.C
 				close(blockHeadersMessageChan)
 				return
 			}
+			if len(blockHeadersMessage.BlockHeaders) == 0 {
+				// The syncer should have sent a done message if the search completed, and not an empty list
+				errChan <- protocolerrors.Errorf(true, "Received an empty headers message from peer %s", flow.peer)
+				return
+			}
 
 			blockHeadersMessageChan <- blockHeadersMessage
 
@@ -336,19 +370,10 @@ func (flow *handleIBDFlow) syncPruningPointFutureHeaders(consensus externalapi.C
 		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
+				return flow.syncMissingRelayPast(consensus, syncerHeaderSelectedTipHash, relayBlockHash)
 			}
 			for _, header := range ibdBlocksMessage.BlockHeaders {
-				_, err := flow.processHeader(consensus, header)
+				err = flow.processHeader(consensus, header)
 				if err != nil {
 					return err
 				}
@@ -362,11 +387,70 @@ func (flow *handleIBDFlow) syncPruningPointFutureHeaders(consensus externalapi.C
 	}
 }
 
-func (flow *handleIBDFlow) sendRequestHeaders(highestSharedBlockHash *externalapi.DomainHash,
-	peerSelectedTipHash *externalapi.DomainHash) error {
+func (flow *handleIBDFlow) syncMissingRelayPast(consensus externalapi.Consensus, syncerHeaderSelectedTipHash *externalapi.DomainHash, relayBlockHash *externalapi.DomainHash) error {
+	// Finished downloading syncer selected tip blocks,
+	// check if we already have the triggering relayBlockHash
+	relayBlockInfo, err := consensus.GetBlockInfo(relayBlockHash)
+	if err != nil {
+		return err
+	}
+	if !relayBlockInfo.Exists {
+		// Send a special header request for the selected tip anticone. This is expected to
+		// be a small set, as it is bounded to the size of virtual's mergeset.
+		err = flow.sendRequestAnticone(syncerHeaderSelectedTipHash, relayBlockHash)
+		if err != nil {
+			return err
+		}
+		anticoneHeadersMessage, anticoneDone, err := flow.receiveHeaders()
+		if err != nil {
+			return err
+		}
+		if anticoneDone {
+			return protocolerrors.Errorf(true,
+				"Expected one anticone header chunk for past(%s) cap anticone(%s) but got zero",
+				relayBlockHash, syncerHeaderSelectedTipHash)
+		}
+		_, anticoneDone, err = flow.receiveHeaders()
+		if err != nil {
+			return err
+		}
+		if !anticoneDone {
+			return protocolerrors.Errorf(true,
+				"Expected only one anticone header chunk for past(%s) cap anticone(%s)",
+				relayBlockHash, syncerHeaderSelectedTipHash)
+		}
+		for _, header := range anticoneHeadersMessage.BlockHeaders {
+			err = flow.processHeader(consensus, header)
+			if err != nil {
+				return err
+			}
+		}
+	}
 
-	msgGetBlockInvs := appmessage.NewMsgRequstHeaders(highestSharedBlockHash, peerSelectedTipHash)
-	return flow.outgoingRoute.Enqueue(msgGetBlockInvs)
+	// If the relayBlockHash has still not been received, the peer is misbehaving
+	relayBlockInfo, err = consensus.GetBlockInfo(relayBlockHash)
+	if err != nil {
+		return err
+	}
+	if !relayBlockInfo.Exists {
+		return protocolerrors.Errorf(true, "did not receive "+
+			"relayBlockHash block %s from peer %s during block download", relayBlockHash, flow.peer)
+	}
+	return nil
+}
+
+func (flow *handleIBDFlow) sendRequestAnticone(
+	syncerHeaderSelectedTipHash, relayBlockHash *externalapi.DomainHash) error {
+
+	msgRequestAnticone := appmessage.NewMsgRequestAnticone(syncerHeaderSelectedTipHash, relayBlockHash)
+	return flow.outgoingRoute.Enqueue(msgRequestAnticone)
+}
+
+func (flow *handleIBDFlow) sendRequestHeaders(
+	highestKnownSyncerChainHash, syncerHeaderSelectedTipHash *externalapi.DomainHash) error {
+
+	msgRequestHeaders := appmessage.NewMsgRequstHeaders(highestKnownSyncerChainHash, syncerHeaderSelectedTipHash)
+	return flow.outgoingRoute.Enqueue(msgRequestHeaders)
 }
 
 func (flow *handleIBDFlow) receiveHeaders() (msgIBDBlock *appmessage.BlockHeadersMessage, doneHeaders bool, err error) {
@@ -389,7 +473,7 @@ func (flow *handleIBDFlow) receiveHeaders() (msgIBDBlock *appmessage.BlockHeader
 	}
 }
 
-func (flow *handleIBDFlow) processHeader(consensus externalapi.Consensus, msgBlockHeader *appmessage.MsgBlockHeader) (bool, error) {
+func (flow *handleIBDFlow) processHeader(consensus externalapi.Consensus, msgBlockHeader *appmessage.MsgBlockHeader) error {
 	header := appmessage.BlockHeaderToDomainBlockHeader(msgBlockHeader)
 	block := &externalapi.DomainBlock{
 		Header:       header,
@@ -399,26 +483,27 @@ func (flow *handleIBDFlow) processHeader(consensus externalapi.Consensus, msgBlo
 	blockHash := consensushashing.BlockHash(block)
 	blockInfo, err := consensus.GetBlockInfo(blockHash)
 	if err != nil {
-		return false, err
+		return err
 	}
 	if blockInfo.Exists {
 		log.Debugf("Block header %s is already in the DAG. Skipping...", blockHash)
-		return false, nil
+		return nil
 	}
 	_, err = consensus.ValidateAndInsertBlock(block, false)
 	if err != nil {
 		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return false, errors.Wrapf(err, "failed to process header %s during IBD", blockHash)
+			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 false, protocolerrors.Wrapf(true, err, "got invalid block header %s during IBD", blockHash)
+			return protocolerrors.Wrapf(true, err, "got invalid block header %s during IBD", blockHash)
 		}
 	}
-	return true, nil
+
+	return nil
 }
 
 func (flow *handleIBDFlow) validatePruningPointFutureHeaderTimestamps() error {
@@ -633,6 +718,10 @@ func (flow *handleIBDFlow) resolveVirtual(estimatedVirtualDAAScoreTarget uint64)
 
 		if isCompletelyResolved {
 			log.Infof("Resolved virtual")
+			err = flow.OnNewBlockTemplate()
+			if err != nil {
+				return err
+			}
 			return nil
 		}
 	}

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

@@ -10,6 +10,10 @@ type ibdProgressReporter struct {
 }
 
 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,
@@ -23,7 +27,16 @@ func newIBDProgressReporter(lowDAAScore uint64, highDAAScore uint64, objectName
 func (ipr *ibdProgressReporter) reportProgress(processedDelta int, highestProcessedDAAScore uint64) {
 	ipr.processed += processedDelta
 
-	relativeDAAScore := highestProcessedDAAScore - ipr.lowDAAScore
+	// 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)

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

@@ -12,18 +12,20 @@ import (
 	"time"
 )
 
-func (flow *handleIBDFlow) ibdWithHeadersProof(highHash *externalapi.DomainHash, highBlockDAAScore uint64) error {
-	err := flow.Domain().InitStagingConsensus()
+func (flow *handleIBDFlow) ibdWithHeadersProof(
+	syncerHeaderSelectedTipHash, relayBlockHash *externalapi.DomainHash, highBlockDAAScore uint64) error {
+	err := flow.Domain().InitStagingConsensusWithoutGenesis()
 	if err != nil {
 		return err
 	}
 
-	err = flow.downloadHeadersAndPruningUTXOSet(highHash, highBlockDAAScore)
+	err = flow.downloadHeadersAndPruningUTXOSet(syncerHeaderSelectedTipHash, relayBlockHash, 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
@@ -32,6 +34,8 @@ func (flow *handleIBDFlow) ibdWithHeadersProof(highHash *externalapi.DomainHash,
 		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
@@ -45,11 +49,29 @@ func (flow *handleIBDFlow) ibdWithHeadersProof(highHash *externalapi.DomainHash,
 	return nil
 }
 
-func (flow *handleIBDFlow) shouldSyncAndShouldDownloadHeadersProof(highBlock *externalapi.DomainBlock,
-	highestSharedBlockFound bool) (shouldDownload, shouldSync bool, err error) {
+func (flow *handleIBDFlow) shouldSyncAndShouldDownloadHeadersProof(
+	relayBlock *externalapi.DomainBlock,
+	highestKnownSyncerChainHash *externalapi.DomainHash) (shouldDownload, shouldSync bool, err error) {
 
-	if !highestSharedBlockFound {
-		hasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore, err := flow.checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore(highBlock)
+	var highestSharedBlockFound, isPruningPointInSharedBlockChain bool
+	if highestKnownSyncerChainHash != nil {
+		highestSharedBlockFound = true
+		pruningPoint, err := flow.Domain().Consensus().PruningPoint()
+		if err != nil {
+			return false, false, err
+		}
+
+		isPruningPointInSharedBlockChain, err = flow.Domain().Consensus().IsInSelectedParentChainOf(
+			pruningPoint, highestKnownSyncerChainHash)
+		if err != nil {
+			return false, false, err
+		}
+	}
+	// Note: in the case where `highestSharedBlockFound == true && isPruningPointInSharedBlockChain == false`
+	// we might have here info which is relevant to finality conflict decisions. This should be taken into
+	// account when we improve this aspect.
+	if !highestSharedBlockFound || !isPruningPointInSharedBlockChain {
+		hasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore, err := flow.checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore(relayBlock)
 		if err != nil {
 			return false, false, err
 		}
@@ -64,7 +86,7 @@ func (flow *handleIBDFlow) shouldSyncAndShouldDownloadHeadersProof(highBlock *ex
 	return false, true, nil
 }
 
-func (flow *handleIBDFlow) checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore(highBlock *externalapi.DomainBlock) (bool, error) {
+func (flow *handleIBDFlow) checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore(relayBlock *externalapi.DomainBlock) (bool, error) {
 	headersSelectedTip, err := flow.Domain().Consensus().GetHeadersSelectedTip()
 	if err != nil {
 		return false, err
@@ -75,11 +97,11 @@ func (flow *handleIBDFlow) checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruni
 		return false, err
 	}
 
-	if highBlock.Header.BlueScore() < headersSelectedTipInfo.BlueScore+flow.Config().NetParams().PruningDepth() {
+	if relayBlock.Header.BlueScore() < headersSelectedTipInfo.BlueScore+flow.Config().NetParams().PruningDepth() {
 		return false, nil
 	}
 
-	return highBlock.Header.BlueWork().Cmp(headersSelectedTipInfo.BlueWork) > 0, nil
+	return relayBlock.Header.BlueWork().Cmp(headersSelectedTipInfo.BlueWork) > 0, nil
 }
 
 func (flow *handleIBDFlow) syncAndValidatePruningPointProof() (*externalapi.DomainHash, error) {
@@ -114,7 +136,10 @@ func (flow *handleIBDFlow) syncAndValidatePruningPointProof() (*externalapi.Doma
 	return consensushashing.HeaderHash(pruningPointProof.Headers[0][len(pruningPointProof.Headers[0])-1]), nil
 }
 
-func (flow *handleIBDFlow) downloadHeadersAndPruningUTXOSet(highHash *externalapi.DomainHash, highBlockDAAScore uint64) error {
+func (flow *handleIBDFlow) downloadHeadersAndPruningUTXOSet(
+	syncerHeaderSelectedTipHash, relayBlockHash *externalapi.DomainHash,
+	highBlockDAAScore uint64) error {
+
 	proofPruningPoint, err := flow.syncAndValidatePruningPointProof()
 	if err != nil {
 		return err
@@ -131,19 +156,20 @@ func (flow *handleIBDFlow) downloadHeadersAndPruningUTXOSet(highHash *externalap
 		return protocolerrors.Errorf(true, "the genesis pruning point violates finality")
 	}
 
-	err = flow.syncPruningPointFutureHeaders(flow.Domain().StagingConsensus(), proofPruningPoint, highHash, highBlockDAAScore)
+	err = flow.syncPruningPointFutureHeaders(flow.Domain().StagingConsensus(),
+		syncerHeaderSelectedTipHash, proofPruningPoint, relayBlockHash, highBlockDAAScore)
 	if err != nil {
 		return err
 	}
 
 	log.Infof("Headers downloaded from peer %s", flow.peer)
 
-	highHashInfo, err := flow.Domain().StagingConsensus().GetBlockInfo(highHash)
+	relayBlockInfo, err := flow.Domain().StagingConsensus().GetBlockInfo(relayBlockHash)
 	if err != nil {
 		return err
 	}
 
-	if !highHashInfo.Exists {
+	if !relayBlockInfo.Exists {
 		return protocolerrors.Errorf(true, "the triggering IBD block was not sent")
 	}
 
@@ -206,7 +232,8 @@ func (flow *handleIBDFlow) syncPruningPointsAndPruningPointAnticone(proofPruning
 		return err
 	}
 
-	for {
+	i := 0
+	for ; ; i++ {
 		blockWithTrustedData, done, err := flow.receiveBlockWithTrustedData()
 		if err != nil {
 			return err
@@ -220,9 +247,19 @@ func (flow *handleIBDFlow) syncPruningPointsAndPruningPointAnticone(proofPruning
 		if err != nil {
 			return err
 		}
+
+		// We're using i+2 because we want to check if the next block will belong to the next batch, but we already downloaded
+		// the pruning point outside the loop so we use i+2 instead of i+1.
+		if (i+2)%ibdBatchSize == 0 {
+			log.Infof("Downloaded %d blocks from the pruning point anticone", i+1)
+			err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestNextPruningPointAndItsAnticoneBlocks())
+			if err != nil {
+				return err
+			}
+		}
 	}
 
-	log.Infof("Finished downloading pruning point and its anticone from %s", flow.peer)
+	log.Infof("Finished downloading pruning point and its anticone from %s. Total blocks downloaded: %d", flow.peer, i+1)
 	return nil
 }
 
@@ -344,6 +381,7 @@ func (flow *handleIBDFlow) syncPruningPointUTXOSet(consensus externalapi.Consens
 	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
 	}
 

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

@@ -2,6 +2,8 @@ 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"
@@ -61,6 +63,9 @@ func (flow *sendPingsFlow) start() error {
 
 		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)

app/protocol/flows/v5/register.go

@@ -1,14 +1,14 @@
-package v4
+package v5
 
 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"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v5/addressexchange"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v5/blockrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v5/ping"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v5/rejects"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v5/transactionrelay"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	routerpkg "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
@@ -78,6 +78,7 @@ func registerBlockRelayFlows(m protocolManager, router *routerpkg.Router, isStop
 			appmessage.CmdDonePruningPointUTXOSetChunks, appmessage.CmdIBDBlock, appmessage.CmdPruningPoints,
 			appmessage.CmdPruningPointProof,
 			appmessage.CmdTrustedData,
+			appmessage.CmdIBDChainBlockLocator,
 		},
 			isStopping, errChan, func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
 				return blockrelay.HandleIBD(m.Context(), incomingRoute,
@@ -121,7 +122,7 @@ func registerBlockRelayFlows(m protocolManager, router *routerpkg.Router, isStop
 		),
 
 		m.RegisterFlow("HandlePruningPointAndItsAnticoneRequests", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointAndItsAnticone}, isStopping, errChan,
+			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointAndItsAnticone, appmessage.CmdRequestNextPruningPointAndItsAnticoneBlocks}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
 				return blockrelay.HandlePruningPointAndItsAnticoneRequests(m.Context(), incomingRoute, outgoingRoute, peer)
 			},
@@ -134,6 +135,20 @@ func registerBlockRelayFlows(m protocolManager, router *routerpkg.Router, isStop
 			},
 		),
 
+		m.RegisterFlow("HandleRequestIBDChainBlockLocator", router,
+			[]appmessage.MessageCommand{appmessage.CmdRequestIBDChainBlockLocator}, isStopping, errChan,
+			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
+				return blockrelay.HandleRequestIBDChainBlockLocator(m.Context(), incomingRoute, outgoingRoute)
+			},
+		),
+
+		m.RegisterFlow("HandleRequestAnticone", router,
+			[]appmessage.MessageCommand{appmessage.CmdRequestAnticone}, isStopping, errChan,
+			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
+				return blockrelay.HandleRequestAnticone(m.Context(), incomingRoute, outgoingRoute, peer)
+			},
+		),
+
 		m.RegisterFlow("HandlePruningPointProofRequests", router,
 			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointProof}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {

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

@@ -1,7 +1,7 @@
 package testing
 
 import (
-	"github.com/kaspanet/kaspad/app/protocol/flows/v4/addressexchange"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v5/addressexchange"
 	"testing"
 	"time"
 

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

@@ -22,7 +22,7 @@ type TransactionsRelayContext interface {
 	SharedRequestedTransactions() *flowcontext.SharedRequestedTransactions
 	OnTransactionAddedToMempool()
 	EnqueueTransactionIDsForPropagation(transactionIDs []*externalapi.DomainTransactionID) error
-	IsIBDRunning() bool
+	IsNearlySynced() (bool, error)
 }
 
 type handleRelayedTransactionsFlow struct {
@@ -50,7 +50,12 @@ func (flow *handleRelayedTransactionsFlow) start() error {
 			return err
 		}
 
-		if flow.IsIBDRunning() {
+		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
 		}
 

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

@@ -3,7 +3,7 @@ package transactionrelay_test
 import (
 	"errors"
 	"github.com/kaspanet/kaspad/app/protocol/flowcontext"
-	"github.com/kaspanet/kaspad/app/protocol/flows/v4/transactionrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v5/transactionrelay"
 	"strings"
 	"testing"
 
@@ -47,8 +47,8 @@ func (m *mocTransactionsRelayContext) EnqueueTransactionIDsForPropagation(transa
 func (m *mocTransactionsRelayContext) OnTransactionAddedToMempool() {
 }
 
-func (m *mocTransactionsRelayContext) IsIBDRunning() bool {
-	return false
+func (m *mocTransactionsRelayContext) IsNearlySynced() (bool, error) {
+	return true, nil
 }
 
 // TestHandleRelayedTransactionsNotFound tests the flow of  HandleRelayedTransactions when the peer doesn't

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

@@ -2,7 +2,7 @@ package transactionrelay_test
 
 import (
 	"github.com/kaspanet/kaspad/app/protocol/flowcontext"
-	"github.com/kaspanet/kaspad/app/protocol/flows/v4/transactionrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v5/transactionrelay"
 	"testing"
 
 	"github.com/kaspanet/kaspad/app/appmessage"

app/protocol/manager.go

@@ -100,6 +100,11 @@ func (m *Manager) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler flowconte
 	m.context.SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler)
 }
 
+// SetOnNewBlockTemplateHandler sets the onNewBlockTemplate handler
+func (m *Manager) SetOnNewBlockTemplateHandler(onNewBlockTemplateHandler flowcontext.OnNewBlockTemplateHandler) {
+	m.context.SetOnNewBlockTemplateHandler(onNewBlockTemplateHandler)
+}
+
 // SetOnPruningPointUTXOSetOverrideHandler sets the OnPruningPointUTXOSetOverride handler
 func (m *Manager) SetOnPruningPointUTXOSetOverrideHandler(onPruningPointUTXOSetOverrideHandler flowcontext.OnPruningPointUTXOSetOverrideHandler) {
 	m.context.SetOnPruningPointUTXOSetOverrideHandler(onPruningPointUTXOSetOverrideHandler)
@@ -113,7 +118,7 @@ func (m *Manager) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMemp
 // ShouldMine returns whether it's ok to use block template from this node
 // for mining purposes.
 func (m *Manager) ShouldMine() (bool, error) {
-	return m.context.ShouldMine()
+	return m.context.IsNearlySynced()
 }
 
 // IsIBDRunning returns true if IBD is currently marked as running

app/protocol/protocol.go

@@ -3,7 +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"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v5"
 	"sync"
 	"sync/atomic"
 
@@ -76,8 +76,8 @@ 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:
 			panic(errors.Errorf("no way to handle protocol version %d", peer.ProtocolVersion()))
 		}

app/rpc/manager.go

@@ -68,7 +68,7 @@ func (m *Manager) NotifyBlockAddedToDAG(block *externalapi.DomainBlock, virtualC
 
 // NotifyVirtualChange notifies the manager that the virtual block has been changed.
 func (m *Manager) NotifyVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyBlockAddedToDAG")
+	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualChange")
 	defer onEnd()
 
 	if m.context.Config.UTXOIndex {
@@ -96,6 +96,13 @@ func (m *Manager) NotifyVirtualChange(virtualChangeSet *externalapi.VirtualChang
 	return nil
 }
 
+// NotifyNewBlockTemplate notifies the manager that a new
+// block template is available for miners
+func (m *Manager) NotifyNewBlockTemplate() error {
+	notification := appmessage.NewNewBlockTemplateNotificationMessage()
+	return m.context.NotificationManager.NotifyNewBlockTemplate(notification)
+}
+
 // NotifyPruningPointUTXOSetOverride notifies the manager whenever the UTXO index
 // resets due to pruning point change via IBD.
 func (m *Manager) NotifyPruningPointUTXOSetOverride() error {

app/rpc/rpc.go

@@ -48,6 +48,7 @@ var handlers = map[appmessage.MessageCommand]handler{
 	appmessage.CmdStopNotifyingPruningPointUTXOSetOverrideRequestMessage:    rpchandlers.HandleStopNotifyingPruningPointUTXOSetOverrideRequest,
 	appmessage.CmdEstimateNetworkHashesPerSecondRequestMessage:              rpchandlers.HandleEstimateNetworkHashesPerSecond,
 	appmessage.CmdNotifyVirtualDaaScoreChangedRequestMessage:                rpchandlers.HandleNotifyVirtualDaaScoreChanged,
+	appmessage.CmdNotifyNewBlockTemplateRequestMessage:                      rpchandlers.HandleNotifyNewBlockTemplate,
 }
 
 func (m *Manager) routerInitializer(router *router.Router, netConnection *netadapter.NetConnection) {

app/rpc/rpccontext/notificationmanager.go

@@ -32,6 +32,7 @@ type NotificationListener struct {
 	propagateVirtualSelectedParentBlueScoreChangedNotifications bool
 	propagateVirtualDaaScoreChangedNotifications                bool
 	propagatePruningPointUTXOSetOverrideNotifications           bool
+	propagateNewBlockTemplateNotifications                      bool
 
 	propagateUTXOsChangedNotificationAddresses map[utxoindex.ScriptPublicKeyString]*UTXOsChangedNotificationAddress
 }
@@ -201,6 +202,25 @@ func (nm *NotificationManager) NotifyVirtualDaaScoreChanged(
 	return nil
 }
 
+// NotifyNewBlockTemplate notifies the notification manager that a new
+// block template is available for miners
+func (nm *NotificationManager) NotifyNewBlockTemplate(
+	notification *appmessage.NewBlockTemplateNotificationMessage) error {
+
+	nm.RLock()
+	defer nm.RUnlock()
+
+	for router, listener := range nm.listeners {
+		if listener.propagateNewBlockTemplateNotifications {
+			err := router.OutgoingRoute().Enqueue(notification)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 // NotifyPruningPointUTXOSetOverride notifies the notification manager that the UTXO index
 // reset due to pruning point change via IBD.
 func (nm *NotificationManager) NotifyPruningPointUTXOSetOverride() error {
@@ -226,6 +246,7 @@ func newNotificationListener() *NotificationListener {
 		propagateFinalityConflictResolvedNotifications:              false,
 		propagateUTXOsChangedNotifications:                          false,
 		propagateVirtualSelectedParentBlueScoreChangedNotifications: false,
+		propagateNewBlockTemplateNotifications:                      false,
 		propagatePruningPointUTXOSetOverrideNotifications:           false,
 	}
 }
@@ -334,6 +355,12 @@ func (nl *NotificationListener) PropagateVirtualDaaScoreChangedNotifications() {
 	nl.propagateVirtualDaaScoreChangedNotifications = true
 }
 
+// PropagateNewBlockTemplateNotifications instructs the listener to send
+// new block template notifications to the remote listener
+func (nl *NotificationListener) PropagateNewBlockTemplateNotifications() {
+	nl.propagateNewBlockTemplateNotifications = true
+}
+
 // PropagatePruningPointUTXOSetOverrideNotifications instructs the listener to send pruning point UTXO set override notifications
 // to the remote listener.
 func (nl *NotificationListener) PropagatePruningPointUTXOSetOverrideNotifications() {

app/rpc/rpchandlers/get_block_template.go

@@ -4,9 +4,11 @@ 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"
+	"github.com/kaspanet/kaspad/version"
 )
 
 // HandleGetBlockTemplate handles the respectively named RPC command
@@ -15,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
 	}
@@ -25,12 +27,18 @@ func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, reque
 		return nil, err
 	}
 
-	coinbaseData := &externalapi.DomainCoinbaseData{ScriptPublicKey: scriptPublicKey}
-
+	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()

app/rpc/rpchandlers/get_blocks_test.go

@@ -31,7 +31,7 @@ func (d fakeDomain) StagingConsensus() externalapi.Consensus {
 	panic("implement me")
 }
 
-func (d fakeDomain) InitStagingConsensus() error {
+func (d fakeDomain) InitStagingConsensusWithoutGenesis() error {
 	panic("implement me")
 }
 

app/rpc/rpchandlers/notify_new_block_template.go

@@ -0,0 +1,19 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleNotifyNewBlockTemplate handles the respectively named RPC command
+func HandleNotifyNewBlockTemplate(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	listener, err := context.NotificationManager.Listener(router)
+	if err != nil {
+		return nil, err
+	}
+	listener.PropagateNewBlockTemplateNotifications()
+
+	response := appmessage.NewNotifyNewBlockTemplateResponseMessage()
+	return response, nil
+}

app/rpc/rpchandlers/submit_block.go

@@ -1,6 +1,7 @@
 package rpchandlers
 
 import (
+	"encoding/json"
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
@@ -58,6 +59,12 @@ func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request ap
 			return nil, err
 		}
 
+		jsonBytes, _ := json.MarshalIndent(submitBlockRequest.Block.Header, "", "    ")
+		if jsonBytes != nil {
+			log.Warnf("The RPC submitted block triggered a rule/protocol error (%s), printing "+
+				"the full header for debug purposes: \n%s", err, string(jsonBytes))
+		}
+
 		return &appmessage.SubmitBlockResponseMessage{
 			Error:        appmessage.RPCErrorf("Block rejected. Reason: %s", err),
 			RejectReason: appmessage.RejectReasonBlockInvalid,

build_and_test.sh

@@ -5,9 +5,8 @@ FLAGS=$@
 go version
 
 go get $FLAGS -t -d ./...
-# This is to bypass a go bug: https://github.com/golang/go/issues/27643
-GO111MODULE=off go get $FLAGS golang.org/x/lint/golint \
-                          honnef.co/go/tools/cmd/staticcheck
+GO111MODULE=off go get $FLAGS golang.org/x/lint/golint
+go install $FLAGS honnef.co/go/tools/cmd/staticcheck@latest
 
 test -z "$(go fmt ./...)"
 

changelog.txt

@@ -1,3 +1,49 @@
+Kaspad v0.11.15 - 2022-04-05
+===========================
+* Add support for auto-compound in `kaspawallet send` (#1951)
+* Unite reachability stores (#1963, #1993, #2001)
+* Add names to nameless routes (#1986)
+* Optimize the miner-kaspad flow and latency (#1988)
+* Upgrade to go 1.18 (#1992)
+* Add package name to kaspawalletd .proto file (#1991)
+* Block template cache  (#1994)
+* Add extra data to GetBlockTemplate request (#1995, #1997)
+* New definition for "out of sync"  (#1996)
+* Remove v4 p2p version (#1998)
+* Remove increase pagefile from deploy.yaml (#2000)
+* Cache the pruning point anticone (#2002)
+* Add DB compaction after the deletion of a DB prefix (#2003)
+* Fixed a bug in staging of pruning point by index (#2005)
+* Clean up debug log level by moving many frequent logs to trace level (#2004)
+
+Kaspad v0.11.14 - 2022-03-20
+===========================
+* Fix a bug in the new p2p v5 IBD chain negotiation (#1981)
+
+Kaspad v0.11.13 - 2022-03-16
+===========================
+* Display progress of IBD process in Kaspad logs (#1938, #1939, #1949, #1977)
+* Optimize DB writes during fresh IBD (#1937)
+* Add AllowConnectionToDifferentVersions flag to kaspactl (#1940)
+* Drop support for p2p v3 (#1942)
+* Various transaction processing fixes and workarounds (#1943, #1946, #1971, #1974)
+* Make kaspawallet store the utxos sorted by amount (#1947)
+* Implement a `parse` sub command in the kaspawallet (#1953)
+* Set MaxBlockLevels for non-mainnet networks to 250 (#1952)
+* Add cache to DAA block window (#1948)
+* kaspactl: string slice parser for GetUtxosByAddresses (#1955, first contribution by @icook)
+* Add MergeSet and IsChainBlock to RPC (#1961)
+* Ignore transaction invs during IBD (#1960)
+* Optimize validation of expected header pruning point (#1962)
+* Fix a bug in bounded marge depth validation (#1966)
+* Don't relay blocks in virtual anticone (#1970)
+* Add version to block template to allow tracking of miner's kaspad version (#1967)
+* New p2p version: v5 (#1969)
+* Fix IBD shared past negotiation to be non quadratic also in the worst-case (#1969, p2p v5)
+* Send pruning point anticone in batches (#1973, p2p v5)
+* Cleanup log output mistakes and try to be more clear to the user (#1976, #1978)
+* Apply avoiding IBD logic from patch10 to p2p v4 IBD handling (#1979)
+
 Kaspad v0.11.11 - 2022-01-27
 ===========================
 * Fix for rare consensus bug regarding DAA window order. The bug only affected IBD from scratch and only today (#1934)

cmd/kaspactl/README.md

@@ -4,7 +4,7 @@ kaspactl is an RPC client for kaspad
 
 ## Requirements
 
-Go 1.16 or later.
+Go 1.18 or later.
 
 ## Installation
 

cmd/kaspactl/docker/Dockerfile

@@ -1,5 +1,5 @@
 # -- multistage docker build: stage #1: build stage
-FROM golang:1.16-alpine AS build
+FROM golang:1.18-alpine AS build
 
 RUN mkdir -p /go/src/github.com/kaspanet/kaspad
 

cmd/kaspaminer/README.md

@@ -4,7 +4,7 @@ Kaspaminer is a CPU-based miner for kaspad
 
 ## Requirements
 
-Go 1.16 or later.
+Go 1.18 or later.
 
 ## Installation
 

cmd/kaspaminer/client.go

@@ -13,8 +13,8 @@ const minerTimeout = 10 * time.Second
 type minerClient struct {
 	*rpcclient.RPCClient
 
-	cfg                        *configFlags
-	blockAddedNotificationChan chan struct{}
+	cfg                              *configFlags
+	newBlockTemplateNotificationChan chan struct{}
 }
 
 func (mc *minerClient) connect() error {
@@ -30,14 +30,14 @@ func (mc *minerClient) connect() error {
 	mc.SetTimeout(minerTimeout)
 	mc.SetLogger(backendLog, logger.LevelTrace)
 
-	err = mc.RegisterForBlockAddedNotifications(func(_ *appmessage.BlockAddedNotificationMessage) {
+	err = mc.RegisterForNewBlockTemplateNotifications(func(_ *appmessage.NewBlockTemplateNotificationMessage) {
 		select {
-		case mc.blockAddedNotificationChan <- struct{}{}:
+		case mc.newBlockTemplateNotificationChan <- struct{}{}:
 		default:
 		}
 	})
 	if err != nil {
-		return errors.Wrapf(err, "error requesting block-added notifications")
+		return errors.Wrapf(err, "error requesting new-block-template notifications")
 	}
 
 	log.Infof("Connected to %s", rpcAddress)
@@ -47,8 +47,8 @@ func (mc *minerClient) connect() error {
 
 func newMinerClient(cfg *configFlags) (*minerClient, error) {
 	minerClient := &minerClient{
-		cfg:                        cfg,
-		blockAddedNotificationChan: make(chan struct{}),
+		cfg:                              cfg,
+		newBlockTemplateNotificationChan: make(chan struct{}),
 	}
 
 	err := minerClient.connect()

cmd/kaspaminer/docker/Dockerfile

@@ -1,5 +1,5 @@
 # -- multistage docker build: stage #1: build stage
-FROM golang:1.16-alpine AS build
+FROM golang:1.18-alpine AS build
 
 RUN mkdir -p /go/src/github.com/kaspanet/kaspad
 

cmd/kaspaminer/mineloop.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	nativeerrors "errors"
+	"github.com/kaspanet/kaspad/version"
 	"math/rand"
 	"sync/atomic"
 	"time"
@@ -187,7 +188,7 @@ func getBlockForMining(mineWhenNotSynced bool) (*externalapi.DomainBlock, *pow.S
 
 func templatesLoop(client *minerClient, miningAddr util.Address, errChan chan error) {
 	getBlockTemplate := func() {
-		template, err := client.GetBlockTemplate(miningAddr.String())
+		template, err := client.GetBlockTemplate(miningAddr.String(), "kaspaminer-"+version.Version())
 		if nativeerrors.Is(err, router.ErrTimeout) {
 			log.Warnf("Got timeout while requesting block template from %s: %s", client.Address(), err)
 			reconnectErr := client.Reconnect()
@@ -217,7 +218,7 @@ func templatesLoop(client *minerClient, miningAddr util.Address, errChan chan er
 	ticker := time.NewTicker(tickerTime)
 	for {
 		select {
-		case <-client.blockAddedNotificationChan:
+		case <-client.newBlockTemplateNotificationChan:
 			getBlockTemplate()
 			ticker.Reset(tickerTime)
 		case <-ticker.C:

cmd/kaspawallet/broadcast.go

@@ -2,13 +2,13 @@ package main
 
 import (
 	"context"
-	"encoding/hex"
 	"fmt"
+	"io/ioutil"
+	"strings"
+
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
 	"github.com/pkg/errors"
-	"io/ioutil"
-	"strings"
 )
 
 func broadcast(conf *broadcastConfig) error {
@@ -21,34 +21,40 @@ func broadcast(conf *broadcastConfig) error {
 	ctx, cancel := context.WithTimeout(context.Background(), daemonTimeout)
 	defer cancel()
 
-	if conf.Transaction == "" && conf.TransactionFile == "" {
+	if conf.Transactions == "" && conf.TransactionsFile == "" {
 		return errors.Errorf("Either --transaction or --transaction-file is required")
 	}
-	if conf.Transaction != "" && conf.TransactionFile != "" {
+	if conf.Transactions != "" && conf.TransactionsFile != "" {
 		return errors.Errorf("Both --transaction and --transaction-file cannot be passed at the same time")
 	}
 
-	transactionHex := conf.Transaction
-	if conf.TransactionFile != "" {
-		transactionHexBytes, err := ioutil.ReadFile(conf.TransactionFile)
+	transactionsHex := conf.Transactions
+	if conf.TransactionsFile != "" {
+		transactionHexBytes, err := ioutil.ReadFile(conf.TransactionsFile)
 		if err != nil {
-			return errors.Wrapf(err, "Could not read hex from %s", conf.TransactionFile)
+			return errors.Wrapf(err, "Could not read hex from %s", conf.TransactionsFile)
 		}
-		transactionHex = strings.TrimSpace(string(transactionHexBytes))
+		transactionsHex = strings.TrimSpace(string(transactionHexBytes))
 	}
 
-	transaction, err := hex.DecodeString(transactionHex)
+	transactions, err := decodeTransactionsFromHex(transactionsHex)
 	if err != nil {
 		return err
 	}
 
-	response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{Transaction: transaction})
-	if err != nil {
-		return err
+	transactionsCount := len(transactions)
+	for i, transaction := range transactions {
+		response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{Transaction: transaction})
+		if err != nil {
+			return err
+		}
+		if transactionsCount == 1 {
+			fmt.Println("Transaction was sent successfully")
+		} else {
+			fmt.Printf("Transaction %d (out of %d) was sent successfully\n", i+1, transactionsCount)
+		}
+		fmt.Printf("Transaction ID: \t%s\n", response.TxID)
 	}
 
-	fmt.Println("Transaction was sent successfully")
-	fmt.Printf("Transaction ID: \t%s\n", response.TxID)
-
 	return nil
 }

cmd/kaspawallet/config.go

@@ -1,9 +1,10 @@
 package main
 
 import (
+	"os"
+
 	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/pkg/errors"
-	"os"
 
 	"github.com/jessevdk/go-flags"
 )
@@ -68,15 +69,15 @@ type createUnsignedTransactionConfig struct {
 type signConfig struct {
 	KeysFile        string `long:"keys-file" short:"f" description:"Keys file location (default: ~/.kaspawallet/keys.json (*nix), %USERPROFILE%\\AppData\\Local\\Kaspawallet\\key.json (Windows))"`
 	Password        string `long:"password" short:"p" description:"Wallet password"`
-	Transaction     string `long:"transaction" short:"t" description:"The unsigned transaction to sign on (encoded in hex)"`
-	TransactionFile string `long:"transaction-file" short:"F" description:"The file containing the unsigned transaction to sign on (encoded in hex)"`
+	Transaction     string `long:"transaction" short:"t" description:"The unsigned transaction(s) to sign on (encoded in hex)"`
+	TransactionFile string `long:"transaction-file" short:"F" description:"The file containing the unsigned transaction(s) to sign on (encoded in hex)"`
 	config.NetworkFlags
 }
 
 type broadcastConfig struct {
-	DaemonAddress   string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
-	Transaction     string `long:"transaction" short:"t" description:"The signed transaction to broadcast (encoded in hex)"`
-	TransactionFile string `long:"transaction-file" short:"F" description:"The file containing the unsigned transaction to sign on (encoded in hex)"`
+	DaemonAddress    string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	Transactions     string `long:"transaction" short:"t" description:"The signed transaction to broadcast (encoded in hex)"`
+	TransactionsFile string `long:"transaction-file" short:"F" description:"The file containing the unsigned transaction to sign on (encoded in hex)"`
 	config.NetworkFlags
 }
 

cmd/kaspawallet/create_unsigned_tx.go

@@ -2,8 +2,8 @@ package main
 
 import (
 	"context"
-	"encoding/hex"
 	"fmt"
+
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
@@ -20,7 +20,7 @@ func createUnsignedTransaction(conf *createUnsignedTransactionConfig) error {
 	defer cancel()
 
 	sendAmountSompi := uint64(conf.SendAmount * constants.SompiPerKaspa)
-	response, err := daemonClient.CreateUnsignedTransaction(ctx, &pb.CreateUnsignedTransactionRequest{
+	response, err := daemonClient.CreateUnsignedTransactions(ctx, &pb.CreateUnsignedTransactionsRequest{
 		Address: conf.ToAddress,
 		Amount:  sendAmountSompi,
 	})
@@ -29,6 +29,6 @@ func createUnsignedTransaction(conf *createUnsignedTransactionConfig) error {
 	}
 
 	fmt.Println("Created unsigned transaction")
-	fmt.Println(hex.EncodeToString(response.UnsignedTransaction))
+	fmt.Println(encodeTransactionsToHex(response.UnsignedTransactions))
 	return nil
 }

cmd/kaspawallet/daemon/pb/kaspawalletd.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.27.1
-// 	protoc        v3.12.3
+// 	protoc-gen-go v1.26.0
+// 	protoc        v3.19.4
 // source: kaspawalletd.proto
 
 package pb
@@ -184,7 +184,7 @@ func (x *AddressBalances) GetPending() uint64 {
 	return 0
 }
 
-type CreateUnsignedTransactionRequest struct {
+type CreateUnsignedTransactionsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
@@ -193,8 +193,8 @@ type CreateUnsignedTransactionRequest struct {
 	Amount  uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
 }
 
-func (x *CreateUnsignedTransactionRequest) Reset() {
-	*x = CreateUnsignedTransactionRequest{}
+func (x *CreateUnsignedTransactionsRequest) Reset() {
+	*x = CreateUnsignedTransactionsRequest{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_kaspawalletd_proto_msgTypes[3]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -202,13 +202,13 @@ func (x *CreateUnsignedTransactionRequest) Reset() {
 	}
 }
 
-func (x *CreateUnsignedTransactionRequest) String() string {
+func (x *CreateUnsignedTransactionsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*CreateUnsignedTransactionRequest) ProtoMessage() {}
+func (*CreateUnsignedTransactionsRequest) ProtoMessage() {}
 
-func (x *CreateUnsignedTransactionRequest) ProtoReflect() protoreflect.Message {
+func (x *CreateUnsignedTransactionsRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_kaspawalletd_proto_msgTypes[3]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -220,35 +220,35 @@ func (x *CreateUnsignedTransactionRequest) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use CreateUnsignedTransactionRequest.ProtoReflect.Descriptor instead.
-func (*CreateUnsignedTransactionRequest) Descriptor() ([]byte, []int) {
+// Deprecated: Use CreateUnsignedTransactionsRequest.ProtoReflect.Descriptor instead.
+func (*CreateUnsignedTransactionsRequest) Descriptor() ([]byte, []int) {
 	return file_kaspawalletd_proto_rawDescGZIP(), []int{3}
 }
 
-func (x *CreateUnsignedTransactionRequest) GetAddress() string {
+func (x *CreateUnsignedTransactionsRequest) GetAddress() string {
 	if x != nil {
 		return x.Address
 	}
 	return ""
 }
 
-func (x *CreateUnsignedTransactionRequest) GetAmount() uint64 {
+func (x *CreateUnsignedTransactionsRequest) GetAmount() uint64 {
 	if x != nil {
 		return x.Amount
 	}
 	return 0
 }
 
-type CreateUnsignedTransactionResponse struct {
+type CreateUnsignedTransactionsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	UnsignedTransaction []byte `protobuf:"bytes,1,opt,name=unsignedTransaction,proto3" json:"unsignedTransaction,omitempty"`
+	UnsignedTransactions [][]byte `protobuf:"bytes,1,rep,name=unsignedTransactions,proto3" json:"unsignedTransactions,omitempty"`
 }
 
-func (x *CreateUnsignedTransactionResponse) Reset() {
-	*x = CreateUnsignedTransactionResponse{}
+func (x *CreateUnsignedTransactionsResponse) Reset() {
+	*x = CreateUnsignedTransactionsResponse{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_kaspawalletd_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -256,13 +256,13 @@ func (x *CreateUnsignedTransactionResponse) Reset() {
 	}
 }
 
-func (x *CreateUnsignedTransactionResponse) String() string {
+func (x *CreateUnsignedTransactionsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*CreateUnsignedTransactionResponse) ProtoMessage() {}
+func (*CreateUnsignedTransactionsResponse) ProtoMessage() {}
 
-func (x *CreateUnsignedTransactionResponse) ProtoReflect() protoreflect.Message {
+func (x *CreateUnsignedTransactionsResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_kaspawalletd_proto_msgTypes[4]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -274,14 +274,14 @@ func (x *CreateUnsignedTransactionResponse) ProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use CreateUnsignedTransactionResponse.ProtoReflect.Descriptor instead.
-func (*CreateUnsignedTransactionResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use CreateUnsignedTransactionsResponse.ProtoReflect.Descriptor instead.
+func (*CreateUnsignedTransactionsResponse) Descriptor() ([]byte, []int) {
 	return file_kaspawalletd_proto_rawDescGZIP(), []int{4}
 }
 
-func (x *CreateUnsignedTransactionResponse) GetUnsignedTransaction() []byte {
+func (x *CreateUnsignedTransactionsResponse) GetUnsignedTransactions() [][]byte {
 	if x != nil {
-		return x.UnsignedTransaction
+		return x.UnsignedTransactions
 	}
 	return nil
 }
@@ -630,80 +630,92 @@ var File_kaspawalletd_proto protoreflect.FileDescriptor
 
 var file_kaspawalletd_proto_rawDesc = []byte{
 	0x0a, 0x12, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x22, 0x13, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e,
-	0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x88, 0x01, 0x0a, 0x12, 0x47, 0x65,
-	0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x1c, 0x0a, 0x09, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x04, 0x52, 0x09, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x18,
-	0x0a, 0x07, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x07, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x3a, 0x0a, 0x0f, 0x61, 0x64, 0x64, 0x72,
-	0x65, 0x73, 0x73, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x10, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x42, 0x61, 0x6c, 0x61, 0x6e,
-	0x63, 0x65, 0x73, 0x52, 0x0f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x42, 0x61, 0x6c, 0x61,
-	0x6e, 0x63, 0x65, 0x73, 0x22, 0x63, 0x0a, 0x0f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x42,
-	0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12,
-	0x18, 0x0a, 0x07, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x07, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x54, 0x0a, 0x20, 0x43, 0x72, 0x65,
-	0x61, 0x74, 0x65, 0x55, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73,
-	0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a,
-	0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e,
-	0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22,
-	0x55, 0x0a, 0x21, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65,
-	0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, 0x13, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64,
-	0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0c, 0x52, 0x13, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73,
-	0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x16, 0x0a, 0x14, 0x53, 0x68, 0x6f, 0x77, 0x41, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x31,
-	0x0a, 0x15, 0x53, 0x68, 0x6f, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x22, 0x13, 0x0a, 0x11, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x2e, 0x0a, 0x12, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07,
-	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x34, 0x0a, 0x10, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63,
-	0x61, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x74, 0x72,
-	0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52,
-	0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x27, 0x0a, 0x11,
-	0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x78, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x04, 0x74, 0x78, 0x49, 0x44, 0x22, 0x11, 0x0a, 0x0f, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77,
-	0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x12, 0x0a, 0x10, 0x53, 0x68, 0x75, 0x74,
-	0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x91, 0x03, 0x0a,
-	0x0c, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x12, 0x37, 0x0a,
-	0x0a, 0x47, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x12, 0x2e, 0x47, 0x65,
-	0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x13, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x64, 0x0a, 0x19, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
-	0x55, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74,
-	0x69, 0x6f, 0x6e, 0x12, 0x21, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x6e, 0x73, 0x69,
-	0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55,
-	0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69,
-	0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x40, 0x0a, 0x0d,
-	0x53, 0x68, 0x6f, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x15, 0x2e,
-	0x53, 0x68, 0x6f, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x37,
-	0x0a, 0x0a, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x12, 0x2e, 0x4e,
-	0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x13, 0x2e, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x31, 0x0a, 0x08, 0x53, 0x68, 0x75, 0x74, 0x64,
-	0x6f, 0x77, 0x6e, 0x12, 0x10, 0x2e, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x34, 0x0a, 0x09, 0x42, 0x72,
-	0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x12, 0x11, 0x2e, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63,
-	0x61, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x12, 0x2e, 0x42, 0x72, 0x6f,
-	0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00,
-	0x42, 0x36, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b,
-	0x61, 0x73, 0x70, 0x61, 0x6e, 0x65, 0x74, 0x2f, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x64, 0x2f, 0x63,
-	0x6d, 0x64, 0x2f, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x2f, 0x64,
-	0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65,
+	0x74, 0x64, 0x22, 0x13, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x95, 0x01, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x42,
+	0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1c,
+	0x0a, 0x09, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x09, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x18, 0x0a, 0x07,
+	0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x70,
+	0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x47, 0x0a, 0x0f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
+	0x73, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x1d, 0x2e, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x0f,
+	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x22,
+	0x63, 0x0a, 0x0f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63,
+	0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x1c, 0x0a, 0x09,
+	0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x09, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x65,
+	0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x70, 0x65, 0x6e,
+	0x64, 0x69, 0x6e, 0x67, 0x22, 0x55, 0x0a, 0x21, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x6e,
+	0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x58, 0x0a, 0x22, 0x43,
+	0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61,
+	0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x32, 0x0a, 0x14, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61,
+	0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52,
+	0x14, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x16, 0x0a, 0x14, 0x53, 0x68, 0x6f, 0x77, 0x41, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x31, 0x0a,
+	0x15, 0x53, 0x68, 0x6f, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
+	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x22, 0x13, 0x0a, 0x11, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x2e, 0x0a, 0x12, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x34, 0x0a, 0x10, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61,
+	0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x74, 0x72, 0x61,
+	0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b,
+	0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x27, 0x0a, 0x11, 0x42,
+	0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x12, 0x0a, 0x04, 0x74, 0x78, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
+	0x74, 0x78, 0x49, 0x44, 0x22, 0x11, 0x0a, 0x0f, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x12, 0x0a, 0x10, 0x53, 0x68, 0x75, 0x74, 0x64,
+	0x6f, 0x77, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xb1, 0x04, 0x0a, 0x0c,
+	0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x12, 0x51, 0x0a, 0x0a,
+	0x47, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x1f, 0x2e, 0x6b, 0x61, 0x73,
+	0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x61, 0x6c,
+	0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6b, 0x61,
+	0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x61,
+	0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
+	0x81, 0x01, 0x0a, 0x1a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x6e, 0x73, 0x69, 0x67, 0x6e,
+	0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2f,
+	0x2e, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x43, 0x72,
+	0x65, 0x61, 0x74, 0x65, 0x55, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e,
+	0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x30, 0x2e, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x43,
+	0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61,
+	0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0d, 0x53, 0x68, 0x6f, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x65, 0x73, 0x12, 0x22, 0x2e, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c,
+	0x65, 0x74, 0x64, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6b, 0x61, 0x73, 0x70, 0x61,
+	0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x41, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
+	0x51, 0x0a, 0x0a, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x1f, 0x2e,
+	0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x4e, 0x65, 0x77,
+	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20,
+	0x2e, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x4e, 0x65,
+	0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x00, 0x12, 0x4b, 0x0a, 0x08, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x1d,
+	0x2e, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x53, 0x68,
+	0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e,
+	0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x53, 0x68, 0x75,
+	0x74, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
+	0x4e, 0x0a, 0x09, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x12, 0x1e, 0x2e, 0x6b,
+	0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x42, 0x72, 0x6f, 0x61,
+	0x64, 0x63, 0x61, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6b,
+	0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x64, 0x2e, 0x42, 0x72, 0x6f, 0x61,
+	0x64, 0x63, 0x61, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42,
+	0x36, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b, 0x61,
+	0x73, 0x70, 0x61, 0x6e, 0x65, 0x74, 0x2f, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x64, 0x2f, 0x63, 0x6d,
+	0x64, 0x2f, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x2f, 0x64, 0x61,
+	0x65, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -720,34 +732,34 @@ func file_kaspawalletd_proto_rawDescGZIP() []byte {
 
 var file_kaspawalletd_proto_msgTypes = make([]protoimpl.MessageInfo, 13)
 var file_kaspawalletd_proto_goTypes = []interface{}{
-	(*GetBalanceRequest)(nil),                 // 0: GetBalanceRequest
-	(*GetBalanceResponse)(nil),                // 1: GetBalanceResponse
-	(*AddressBalances)(nil),                   // 2: AddressBalances
-	(*CreateUnsignedTransactionRequest)(nil),  // 3: CreateUnsignedTransactionRequest
-	(*CreateUnsignedTransactionResponse)(nil), // 4: CreateUnsignedTransactionResponse
-	(*ShowAddressesRequest)(nil),              // 5: ShowAddressesRequest
-	(*ShowAddressesResponse)(nil),             // 6: ShowAddressesResponse
-	(*NewAddressRequest)(nil),                 // 7: NewAddressRequest
-	(*NewAddressResponse)(nil),                // 8: NewAddressResponse
-	(*BroadcastRequest)(nil),                  // 9: BroadcastRequest
-	(*BroadcastResponse)(nil),                 // 10: BroadcastResponse
-	(*ShutdownRequest)(nil),                   // 11: ShutdownRequest
-	(*ShutdownResponse)(nil),                  // 12: ShutdownResponse
+	(*GetBalanceRequest)(nil),                  // 0: kaspawalletd.GetBalanceRequest
+	(*GetBalanceResponse)(nil),                 // 1: kaspawalletd.GetBalanceResponse
+	(*AddressBalances)(nil),                    // 2: kaspawalletd.AddressBalances
+	(*CreateUnsignedTransactionsRequest)(nil),  // 3: kaspawalletd.CreateUnsignedTransactionsRequest
+	(*CreateUnsignedTransactionsResponse)(nil), // 4: kaspawalletd.CreateUnsignedTransactionsResponse
+	(*ShowAddressesRequest)(nil),               // 5: kaspawalletd.ShowAddressesRequest
+	(*ShowAddressesResponse)(nil),              // 6: kaspawalletd.ShowAddressesResponse
+	(*NewAddressRequest)(nil),                  // 7: kaspawalletd.NewAddressRequest
+	(*NewAddressResponse)(nil),                 // 8: kaspawalletd.NewAddressResponse
+	(*BroadcastRequest)(nil),                   // 9: kaspawalletd.BroadcastRequest
+	(*BroadcastResponse)(nil),                  // 10: kaspawalletd.BroadcastResponse
+	(*ShutdownRequest)(nil),                    // 11: kaspawalletd.ShutdownRequest
+	(*ShutdownResponse)(nil),                   // 12: kaspawalletd.ShutdownResponse
 }
 var file_kaspawalletd_proto_depIdxs = []int32{
-	2,  // 0: GetBalanceResponse.addressBalances:type_name -> AddressBalances
-	0,  // 1: kaspawalletd.GetBalance:input_type -> GetBalanceRequest
-	3,  // 2: kaspawalletd.CreateUnsignedTransaction:input_type -> CreateUnsignedTransactionRequest
-	5,  // 3: kaspawalletd.ShowAddresses:input_type -> ShowAddressesRequest
-	7,  // 4: kaspawalletd.NewAddress:input_type -> NewAddressRequest
-	11, // 5: kaspawalletd.Shutdown:input_type -> ShutdownRequest
-	9,  // 6: kaspawalletd.Broadcast:input_type -> BroadcastRequest
-	1,  // 7: kaspawalletd.GetBalance:output_type -> GetBalanceResponse
-	4,  // 8: kaspawalletd.CreateUnsignedTransaction:output_type -> CreateUnsignedTransactionResponse
-	6,  // 9: kaspawalletd.ShowAddresses:output_type -> ShowAddressesResponse
-	8,  // 10: kaspawalletd.NewAddress:output_type -> NewAddressResponse
-	12, // 11: kaspawalletd.Shutdown:output_type -> ShutdownResponse
-	10, // 12: kaspawalletd.Broadcast:output_type -> BroadcastResponse
+	2,  // 0: kaspawalletd.GetBalanceResponse.addressBalances:type_name -> kaspawalletd.AddressBalances
+	0,  // 1: kaspawalletd.kaspawalletd.GetBalance:input_type -> kaspawalletd.GetBalanceRequest
+	3,  // 2: kaspawalletd.kaspawalletd.CreateUnsignedTransactions:input_type -> kaspawalletd.CreateUnsignedTransactionsRequest
+	5,  // 3: kaspawalletd.kaspawalletd.ShowAddresses:input_type -> kaspawalletd.ShowAddressesRequest
+	7,  // 4: kaspawalletd.kaspawalletd.NewAddress:input_type -> kaspawalletd.NewAddressRequest
+	11, // 5: kaspawalletd.kaspawalletd.Shutdown:input_type -> kaspawalletd.ShutdownRequest
+	9,  // 6: kaspawalletd.kaspawalletd.Broadcast:input_type -> kaspawalletd.BroadcastRequest
+	1,  // 7: kaspawalletd.kaspawalletd.GetBalance:output_type -> kaspawalletd.GetBalanceResponse
+	4,  // 8: kaspawalletd.kaspawalletd.CreateUnsignedTransactions:output_type -> kaspawalletd.CreateUnsignedTransactionsResponse
+	6,  // 9: kaspawalletd.kaspawalletd.ShowAddresses:output_type -> kaspawalletd.ShowAddressesResponse
+	8,  // 10: kaspawalletd.kaspawalletd.NewAddress:output_type -> kaspawalletd.NewAddressResponse
+	12, // 11: kaspawalletd.kaspawalletd.Shutdown:output_type -> kaspawalletd.ShutdownResponse
+	10, // 12: kaspawalletd.kaspawalletd.Broadcast:output_type -> kaspawalletd.BroadcastResponse
 	7,  // [7:13] is the sub-list for method output_type
 	1,  // [1:7] is the sub-list for method input_type
 	1,  // [1:1] is the sub-list for extension type_name
@@ -798,7 +810,7 @@ func file_kaspawalletd_proto_init() {
 			}
 		}
 		file_kaspawalletd_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*CreateUnsignedTransactionRequest); i {
+			switch v := v.(*CreateUnsignedTransactionsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -810,7 +822,7 @@ func file_kaspawalletd_proto_init() {
 			}
 		}
 		file_kaspawalletd_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*CreateUnsignedTransactionResponse); i {
+			switch v := v.(*CreateUnsignedTransactionsResponse); i {
 			case 0:
 				return &v.state
 			case 1:

cmd/kaspawallet/daemon/pb/kaspawalletd.proto

@@ -1,10 +1,11 @@
 syntax = "proto3";
 
 option go_package = "github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb";
+package kaspawalletd;
 
 service kaspawalletd {
   rpc GetBalance (GetBalanceRequest) returns (GetBalanceResponse) {}
-  rpc CreateUnsignedTransaction (CreateUnsignedTransactionRequest) returns (CreateUnsignedTransactionResponse) {}
+  rpc CreateUnsignedTransactions (CreateUnsignedTransactionsRequest) returns (CreateUnsignedTransactionsResponse) {}
   rpc ShowAddresses (ShowAddressesRequest) returns (ShowAddressesResponse) {}
   rpc NewAddress (NewAddressRequest) returns (NewAddressResponse) {}
   rpc Shutdown (ShutdownRequest) returns (ShutdownResponse) {}
@@ -26,13 +27,13 @@ message AddressBalances {
     uint64 pending = 3;
 }
 
-message CreateUnsignedTransactionRequest {
+message CreateUnsignedTransactionsRequest {
   string address = 1;
   uint64 amount = 2;
 }
 
-message CreateUnsignedTransactionResponse {
-  bytes unsignedTransaction = 1;
+message CreateUnsignedTransactionsResponse {
+  repeated bytes unsignedTransactions = 1;
 }
 
 message ShowAddressesRequest {

cmd/kaspawallet/daemon/pb/kaspawalletd_grpc.pb.go

@@ -19,7 +19,7 @@ const _ = grpc.SupportPackageIsVersion7
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type KaspawalletdClient interface {
 	GetBalance(ctx context.Context, in *GetBalanceRequest, opts ...grpc.CallOption) (*GetBalanceResponse, error)
-	CreateUnsignedTransaction(ctx context.Context, in *CreateUnsignedTransactionRequest, opts ...grpc.CallOption) (*CreateUnsignedTransactionResponse, error)
+	CreateUnsignedTransactions(ctx context.Context, in *CreateUnsignedTransactionsRequest, opts ...grpc.CallOption) (*CreateUnsignedTransactionsResponse, error)
 	ShowAddresses(ctx context.Context, in *ShowAddressesRequest, opts ...grpc.CallOption) (*ShowAddressesResponse, error)
 	NewAddress(ctx context.Context, in *NewAddressRequest, opts ...grpc.CallOption) (*NewAddressResponse, error)
 	Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error)
@@ -36,16 +36,16 @@ func NewKaspawalletdClient(cc grpc.ClientConnInterface) KaspawalletdClient {
 
 func (c *kaspawalletdClient) GetBalance(ctx context.Context, in *GetBalanceRequest, opts ...grpc.CallOption) (*GetBalanceResponse, error) {
 	out := new(GetBalanceResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd/GetBalance", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/GetBalance", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *kaspawalletdClient) CreateUnsignedTransaction(ctx context.Context, in *CreateUnsignedTransactionRequest, opts ...grpc.CallOption) (*CreateUnsignedTransactionResponse, error) {
-	out := new(CreateUnsignedTransactionResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd/CreateUnsignedTransaction", in, out, opts...)
+func (c *kaspawalletdClient) CreateUnsignedTransactions(ctx context.Context, in *CreateUnsignedTransactionsRequest, opts ...grpc.CallOption) (*CreateUnsignedTransactionsResponse, error) {
+	out := new(CreateUnsignedTransactionsResponse)
+	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/CreateUnsignedTransactions", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -54,7 +54,7 @@ func (c *kaspawalletdClient) CreateUnsignedTransaction(ctx context.Context, in *
 
 func (c *kaspawalletdClient) ShowAddresses(ctx context.Context, in *ShowAddressesRequest, opts ...grpc.CallOption) (*ShowAddressesResponse, error) {
 	out := new(ShowAddressesResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd/ShowAddresses", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/ShowAddresses", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -63,7 +63,7 @@ func (c *kaspawalletdClient) ShowAddresses(ctx context.Context, in *ShowAddresse
 
 func (c *kaspawalletdClient) NewAddress(ctx context.Context, in *NewAddressRequest, opts ...grpc.CallOption) (*NewAddressResponse, error) {
 	out := new(NewAddressResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd/NewAddress", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/NewAddress", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -72,7 +72,7 @@ func (c *kaspawalletdClient) NewAddress(ctx context.Context, in *NewAddressReque
 
 func (c *kaspawalletdClient) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error) {
 	out := new(ShutdownResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd/Shutdown", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/Shutdown", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -81,7 +81,7 @@ func (c *kaspawalletdClient) Shutdown(ctx context.Context, in *ShutdownRequest,
 
 func (c *kaspawalletdClient) Broadcast(ctx context.Context, in *BroadcastRequest, opts ...grpc.CallOption) (*BroadcastResponse, error) {
 	out := new(BroadcastResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd/Broadcast", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/Broadcast", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -93,7 +93,7 @@ func (c *kaspawalletdClient) Broadcast(ctx context.Context, in *BroadcastRequest
 // for forward compatibility
 type KaspawalletdServer interface {
 	GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error)
-	CreateUnsignedTransaction(context.Context, *CreateUnsignedTransactionRequest) (*CreateUnsignedTransactionResponse, error)
+	CreateUnsignedTransactions(context.Context, *CreateUnsignedTransactionsRequest) (*CreateUnsignedTransactionsResponse, error)
 	ShowAddresses(context.Context, *ShowAddressesRequest) (*ShowAddressesResponse, error)
 	NewAddress(context.Context, *NewAddressRequest) (*NewAddressResponse, error)
 	Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error)
@@ -108,8 +108,8 @@ type UnimplementedKaspawalletdServer struct {
 func (UnimplementedKaspawalletdServer) GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetBalance not implemented")
 }
-func (UnimplementedKaspawalletdServer) CreateUnsignedTransaction(context.Context, *CreateUnsignedTransactionRequest) (*CreateUnsignedTransactionResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CreateUnsignedTransaction not implemented")
+func (UnimplementedKaspawalletdServer) CreateUnsignedTransactions(context.Context, *CreateUnsignedTransactionsRequest) (*CreateUnsignedTransactionsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreateUnsignedTransactions not implemented")
 }
 func (UnimplementedKaspawalletdServer) ShowAddresses(context.Context, *ShowAddressesRequest) (*ShowAddressesResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ShowAddresses not implemented")
@@ -146,7 +146,7 @@ func _Kaspawalletd_GetBalance_Handler(srv interface{}, ctx context.Context, dec
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/kaspawalletd/GetBalance",
+		FullMethod: "/kaspawalletd.kaspawalletd/GetBalance",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(KaspawalletdServer).GetBalance(ctx, req.(*GetBalanceRequest))
@@ -154,20 +154,20 @@ func _Kaspawalletd_GetBalance_Handler(srv interface{}, ctx context.Context, dec
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Kaspawalletd_CreateUnsignedTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(CreateUnsignedTransactionRequest)
+func _Kaspawalletd_CreateUnsignedTransactions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateUnsignedTransactionsRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(KaspawalletdServer).CreateUnsignedTransaction(ctx, in)
+		return srv.(KaspawalletdServer).CreateUnsignedTransactions(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/kaspawalletd/CreateUnsignedTransaction",
+		FullMethod: "/kaspawalletd.kaspawalletd/CreateUnsignedTransactions",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(KaspawalletdServer).CreateUnsignedTransaction(ctx, req.(*CreateUnsignedTransactionRequest))
+		return srv.(KaspawalletdServer).CreateUnsignedTransactions(ctx, req.(*CreateUnsignedTransactionsRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -182,7 +182,7 @@ func _Kaspawalletd_ShowAddresses_Handler(srv interface{}, ctx context.Context, d
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/kaspawalletd/ShowAddresses",
+		FullMethod: "/kaspawalletd.kaspawalletd/ShowAddresses",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(KaspawalletdServer).ShowAddresses(ctx, req.(*ShowAddressesRequest))
@@ -200,7 +200,7 @@ func _Kaspawalletd_NewAddress_Handler(srv interface{}, ctx context.Context, dec
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/kaspawalletd/NewAddress",
+		FullMethod: "/kaspawalletd.kaspawalletd/NewAddress",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(KaspawalletdServer).NewAddress(ctx, req.(*NewAddressRequest))
@@ -218,7 +218,7 @@ func _Kaspawalletd_Shutdown_Handler(srv interface{}, ctx context.Context, dec fu
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/kaspawalletd/Shutdown",
+		FullMethod: "/kaspawalletd.kaspawalletd/Shutdown",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(KaspawalletdServer).Shutdown(ctx, req.(*ShutdownRequest))
@@ -236,7 +236,7 @@ func _Kaspawalletd_Broadcast_Handler(srv interface{}, ctx context.Context, dec f
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/kaspawalletd/Broadcast",
+		FullMethod: "/kaspawalletd.kaspawalletd/Broadcast",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(KaspawalletdServer).Broadcast(ctx, req.(*BroadcastRequest))
@@ -248,7 +248,7 @@ func _Kaspawalletd_Broadcast_Handler(srv interface{}, ctx context.Context, dec f
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
 var Kaspawalletd_ServiceDesc = grpc.ServiceDesc{
-	ServiceName: "kaspawalletd",
+	ServiceName: "kaspawalletd.kaspawalletd",
 	HandlerType: (*KaspawalletdServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
@@ -256,8 +256,8 @@ var Kaspawalletd_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _Kaspawalletd_GetBalance_Handler,
 		},
 		{
-			MethodName: "CreateUnsignedTransaction",
-			Handler:    _Kaspawalletd_CreateUnsignedTransaction_Handler,
+			MethodName: "CreateUnsignedTransactions",
+			Handler:    _Kaspawalletd_CreateUnsignedTransactions_Handler,
 		},
 		{
 			MethodName: "ShowAddresses",

cmd/kaspawallet/daemon/server/address.go

@@ -10,15 +10,15 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (s *server) changeAddress() (util.Address, error) {
+func (s *server) changeAddress() (util.Address, *walletAddress, error) {
 	err := s.keysFile.SetLastUsedInternalIndex(s.keysFile.LastUsedInternalIndex() + 1)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	err = s.keysFile.Save()
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	walletAddr := &walletAddress{
@@ -27,7 +27,11 @@ func (s *server) changeAddress() (util.Address, error) {
 		keyChain:      libkaspawallet.InternalKeychain,
 	}
 	path := s.walletAddressPath(walletAddr)
-	return libkaspawallet.Address(s.params, s.keysFile.ExtendedPublicKeys, s.keysFile.MinimumSignatures, path, s.keysFile.ECDSA)
+	address, err := libkaspawallet.Address(s.params, s.keysFile.ExtendedPublicKeys, s.keysFile.MinimumSignatures, path, s.keysFile.ECDSA)
+	if err != nil {
+		return nil, nil, err
+	}
+	return address, walletAddr, nil
 }
 
 func (s *server) ShowAddresses(_ context.Context, request *pb.ShowAddressesRequest) (*pb.ShowAddressesResponse, error) {

cmd/kaspawallet/daemon/server/create_unsigned_transaction.go

@@ -10,7 +10,11 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (s *server) CreateUnsignedTransaction(_ context.Context, request *pb.CreateUnsignedTransactionRequest) (*pb.CreateUnsignedTransactionResponse, error) {
+// TODO: Implement a better fee estimation mechanism
+const feePerInput = 10000
+
+func (s *server) CreateUnsignedTransactions(_ context.Context, request *pb.CreateUnsignedTransactionsRequest) (
+	*pb.CreateUnsignedTransactionsResponse, error) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
@@ -28,14 +32,12 @@ func (s *server) CreateUnsignedTransaction(_ context.Context, request *pb.Create
 		return nil, err
 	}
 
-	// TODO: Implement a better fee estimation mechanism
-	const feePerInput = 10000
 	selectedUTXOs, changeSompi, err := s.selectUTXOs(request.Amount, feePerInput)
 	if err != nil {
 		return nil, err
 	}
 
-	changeAddress, err := s.changeAddress()
+	changeAddress, changeWalletAddress, err := s.changeAddress()
 	if err != nil {
 		return nil, err
 	}
@@ -53,7 +55,12 @@ func (s *server) CreateUnsignedTransaction(_ context.Context, request *pb.Create
 		return nil, err
 	}
 
-	return &pb.CreateUnsignedTransactionResponse{UnsignedTransaction: unsignedTransaction}, nil
+	unsignedTransactions, err := s.maybeAutoCompoundTransaction(unsignedTransaction, toAddress, changeAddress, changeWalletAddress)
+	if err != nil {
+		return nil, err
+	}
+
+	return &pb.CreateUnsignedTransactionsResponse{UnsignedTransactions: unsignedTransactions}, nil
 }
 
 func (s *server) selectUTXOs(spendAmount uint64, feePerInput uint64) (

cmd/kaspawallet/daemon/server/server.go

@@ -7,6 +7,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/kaspanet/kaspad/util/txmass"
+
 	"github.com/kaspanet/kaspad/util/profiling"
 
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
@@ -32,6 +34,7 @@ type server struct {
 	keysFile            *keys.File
 	shutdown            chan struct{}
 	addressSet          walletAddressSet
+	txMassCalculator    *txmass.Calculator
 }
 
 // Start starts the kaspawalletd server
@@ -69,6 +72,7 @@ func Start(params *dagconfig.Params, listen, rpcServer string, keysFilePath stri
 		keysFile:            keysFile,
 		shutdown:            make(chan struct{}),
 		addressSet:          make(walletAddressSet),
+		txMassCalculator:    txmass.NewCalculator(params.MassPerTxByte, params.MassPerScriptPubKeyByte, params.MassPerSigOp),
 	}
 
 	spawn("serverInstance.sync", func() {

cmd/kaspawallet/daemon/server/split_transaction.go

@@ -0,0 +1,278 @@
+package server
+
+import (
+	"github.com/kaspanet/go-secp256k1"
+	"github.com/pkg/errors"
+
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet/serialization"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
+	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
+	"github.com/kaspanet/kaspad/util"
+)
+
+// maybeAutoCompoundTransaction checks if a transaction's mass is higher that what is allowed for a standard
+// transaction.
+// If it is - the transaction is split into multiple transactions, each with a portion of the inputs and a single output
+// into a change address.
+// An additional `mergeTransaction` is generated - which merges the outputs of the above splits into a single output
+// paying to the original transaction's payee.
+func (s *server) maybeAutoCompoundTransaction(transactionBytes []byte, toAddress util.Address,
+	changeAddress util.Address, changeWalletAddress *walletAddress) ([][]byte, error) {
+	transaction, err := serialization.DeserializePartiallySignedTransaction(transactionBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	splitTransactions, err := s.maybeSplitTransaction(transaction, changeAddress)
+	if err != nil {
+		return nil, err
+	}
+	if len(splitTransactions) > 1 {
+		mergeTransaction, err := s.mergeTransaction(splitTransactions, transaction, toAddress, changeAddress, changeWalletAddress)
+		if err != nil {
+			return nil, err
+		}
+		splitTransactions = append(splitTransactions, mergeTransaction)
+	}
+
+	splitTransactionsBytes := make([][]byte, len(splitTransactions))
+	for i, splitTransaction := range splitTransactions {
+		splitTransactionsBytes[i], err = serialization.SerializePartiallySignedTransaction(splitTransaction)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return splitTransactionsBytes, nil
+}
+
+func (s *server) mergeTransaction(
+	splitTransactions []*serialization.PartiallySignedTransaction,
+	originalTransaction *serialization.PartiallySignedTransaction,
+	toAddress util.Address,
+	changeAddress util.Address,
+	changeWalletAddress *walletAddress,
+) (*serialization.PartiallySignedTransaction, error) {
+	numOutputs := len(originalTransaction.Tx.Outputs)
+	if numOutputs > 2 || numOutputs == 0 {
+		// This is a sanity check to make sure originalTransaction has either 1 or 2 outputs:
+		// 1. For the payment itself
+		// 2. (optional) for change
+		return nil, errors.Errorf("original transaction has %d outputs, while 1 or 2 are expected",
+			len(originalTransaction.Tx.Outputs))
+	}
+
+	totalValue := uint64(0)
+	sentValue := originalTransaction.Tx.Outputs[0].Value
+	utxos := make([]*libkaspawallet.UTXO, len(splitTransactions))
+	for i, splitTransaction := range splitTransactions {
+		output := splitTransaction.Tx.Outputs[0]
+		utxos[i] = &libkaspawallet.UTXO{
+			Outpoint: &externalapi.DomainOutpoint{
+				TransactionID: *consensushashing.TransactionID(splitTransaction.Tx),
+				Index:         0,
+			},
+			UTXOEntry:      utxo.NewUTXOEntry(output.Value, output.ScriptPublicKey, false, constants.UnacceptedDAAScore),
+			DerivationPath: s.walletAddressPath(changeWalletAddress),
+		}
+		totalValue += output.Value
+		totalValue -= feePerInput
+	}
+
+	if totalValue < sentValue {
+		// sometimes the fees from compound transactions make the total output higher than what's available from selected
+		// utxos, in such cases - find one more UTXO and use it.
+		additionalUTXOs, totalValueAdded, err := s.moreUTXOsForMergeTransaction(utxos, sentValue-totalValue)
+		if err != nil {
+			return nil, err
+		}
+		utxos = append(utxos, additionalUTXOs...)
+		totalValue += totalValueAdded
+	}
+
+	payments := []*libkaspawallet.Payment{{
+		Address: toAddress,
+		Amount:  sentValue,
+	}}
+	if totalValue > sentValue {
+		payments = append(payments, &libkaspawallet.Payment{
+			Address: changeAddress,
+			Amount:  totalValue - sentValue,
+		})
+	}
+
+	mergeTransactionBytes, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
+		s.keysFile.MinimumSignatures, payments, utxos)
+	if err != nil {
+		return nil, err
+	}
+
+	return serialization.DeserializePartiallySignedTransaction(mergeTransactionBytes)
+}
+
+func (s *server) maybeSplitTransaction(transaction *serialization.PartiallySignedTransaction,
+	changeAddress util.Address) ([]*serialization.PartiallySignedTransaction, error) {
+
+	transactionMass, err := s.estimateMassAfterSignatures(transaction)
+	if err != nil {
+		return nil, err
+	}
+
+	if transactionMass < mempool.MaximumStandardTransactionMass {
+		return []*serialization.PartiallySignedTransaction{transaction}, nil
+	}
+
+	splitCount, inputCountPerSplit, err := s.splitAndInputPerSplitCounts(transaction, transactionMass, changeAddress)
+	if err != nil {
+		return nil, err
+	}
+
+	splitTransactions := make([]*serialization.PartiallySignedTransaction, splitCount)
+	for i := 0; i < splitCount; i++ {
+		startIndex := i * inputCountPerSplit
+		endIndex := startIndex + inputCountPerSplit
+		var err error
+		splitTransactions[i], err = s.createSplitTransaction(transaction, changeAddress, startIndex, endIndex)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return splitTransactions, nil
+}
+
+// splitAndInputPerSplitCounts calculates the number of splits to create, and the number of inputs to assign per split.
+func (s *server) splitAndInputPerSplitCounts(transaction *serialization.PartiallySignedTransaction, transactionMass uint64,
+	changeAddress util.Address) (splitCount, inputsPerSplitCount int, err error) {
+
+	// Create a dummy transaction which is a clone of the original transaction, but without inputs,
+	// to calculate how much mass do all the inputs have
+	transactionWithoutInputs := transaction.Tx.Clone()
+	transactionWithoutInputs.Inputs = []*externalapi.DomainTransactionInput{}
+	massWithoutInputs := s.txMassCalculator.CalculateTransactionMass(transactionWithoutInputs)
+
+	massOfAllInputs := transactionMass - massWithoutInputs
+
+	// Since the transaction was generated by kaspawallet, we assume all inputs have the same number of signatures, and
+	// thus - the same mass.
+	inputCount := len(transaction.Tx.Inputs)
+	massPerInput := massOfAllInputs / uint64(inputCount)
+	if massOfAllInputs%uint64(inputCount) > 0 {
+		massPerInput++
+	}
+
+	// Create another dummy transaction, this time one similar to the split transactions we wish to generate,
+	// but with 0 inputs, to calculate how much mass for inputs do we have available in the split transactions
+	splitTransactionWithoutInputs, err := s.createSplitTransaction(transaction, changeAddress, 0, 0)
+	if err != nil {
+		return 0, 0, err
+	}
+	massForEverythingExceptInputsInSplitTransaction :=
+		s.txMassCalculator.CalculateTransactionMass(splitTransactionWithoutInputs.Tx)
+	massForInputsInSplitTransaction := mempool.MaximumStandardTransactionMass - massForEverythingExceptInputsInSplitTransaction
+
+	inputsPerSplitCount = int(massForInputsInSplitTransaction / massPerInput)
+	splitCount = inputCount / inputsPerSplitCount
+	if inputCount%inputsPerSplitCount > 0 {
+		splitCount++
+	}
+
+	return splitCount, inputsPerSplitCount, nil
+}
+
+func (s *server) createSplitTransaction(transaction *serialization.PartiallySignedTransaction,
+	changeAddress util.Address, startIndex int, endIndex int) (*serialization.PartiallySignedTransaction, error) {
+
+	selectedUTXOs := make([]*libkaspawallet.UTXO, 0, endIndex-startIndex)
+	totalSompi := uint64(0)
+
+	for i := startIndex; i < endIndex && i < len(transaction.PartiallySignedInputs); i++ {
+		partiallySignedInput := transaction.PartiallySignedInputs[i]
+		selectedUTXOs = append(selectedUTXOs, &libkaspawallet.UTXO{
+			Outpoint: &transaction.Tx.Inputs[i].PreviousOutpoint,
+			UTXOEntry: utxo.NewUTXOEntry(
+				partiallySignedInput.PrevOutput.Value, partiallySignedInput.PrevOutput.ScriptPublicKey,
+				false, constants.UnacceptedDAAScore),
+			DerivationPath: partiallySignedInput.DerivationPath,
+		})
+
+		totalSompi += selectedUTXOs[i-startIndex].UTXOEntry.Amount()
+		totalSompi -= feePerInput
+	}
+	unsignedTransactionBytes, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
+		s.keysFile.MinimumSignatures,
+		[]*libkaspawallet.Payment{{
+			Address: changeAddress,
+			Amount:  totalSompi,
+		}}, selectedUTXOs)
+	if err != nil {
+		return nil, err
+	}
+
+	return serialization.DeserializePartiallySignedTransaction(unsignedTransactionBytes)
+}
+
+func (s *server) estimateMassAfterSignatures(transaction *serialization.PartiallySignedTransaction) (uint64, error) {
+	transaction = transaction.Clone()
+	var signatureSize uint64
+	if s.keysFile.ECDSA {
+		signatureSize = secp256k1.SerializedECDSASignatureSize
+	} else {
+		signatureSize = secp256k1.SerializedSchnorrSignatureSize
+	}
+
+	for i, input := range transaction.PartiallySignedInputs {
+		for j, pubKeyPair := range input.PubKeySignaturePairs {
+			if uint32(j) >= s.keysFile.MinimumSignatures {
+				break
+			}
+			pubKeyPair.Signature = make([]byte, signatureSize+1) // +1 for SigHashType
+		}
+		transaction.Tx.Inputs[i].SigOpCount = byte(len(input.PubKeySignaturePairs))
+	}
+
+	transactionWithSignatures, err := libkaspawallet.ExtractTransactionDeserialized(transaction, s.keysFile.ECDSA)
+	if err != nil {
+		return 0, err
+	}
+
+	return s.txMassCalculator.CalculateTransactionMass(transactionWithSignatures), nil
+}
+
+func (s *server) moreUTXOsForMergeTransaction(alreadySelectedUTXOs []*libkaspawallet.UTXO, requiredAmount uint64) (
+	additionalUTXOs []*libkaspawallet.UTXO, totalValueAdded uint64, err error) {
+
+	dagInfo, err := s.rpcClient.GetBlockDAGInfo()
+	if err != nil {
+		return nil, 0, err
+	}
+	alreadySelectedUTXOsMap := make(map[externalapi.DomainOutpoint]struct{}, len(alreadySelectedUTXOs))
+	for _, alreadySelectedUTXO := range alreadySelectedUTXOs {
+		alreadySelectedUTXOsMap[*alreadySelectedUTXO.Outpoint] = struct{}{}
+	}
+
+	for _, utxo := range s.utxosSortedByAmount {
+		if _, ok := alreadySelectedUTXOsMap[*utxo.Outpoint]; ok {
+			continue
+		}
+		if !isUTXOSpendable(utxo, dagInfo.VirtualDAAScore, s.params.BlockCoinbaseMaturity) {
+			continue
+		}
+		additionalUTXOs = append(additionalUTXOs, &libkaspawallet.UTXO{
+			Outpoint:       utxo.Outpoint,
+			UTXOEntry:      utxo.UTXOEntry,
+			DerivationPath: s.walletAddressPath(utxo.address)})
+		totalValueAdded += utxo.UTXOEntry.Amount() - feePerInput
+		if totalValueAdded >= requiredAmount {
+			break
+		}
+	}
+	if totalValueAdded < requiredAmount {
+		return nil, 0, errors.Errorf("Insufficient funds for merge transaction")
+	}
+
+	return additionalUTXOs, totalValueAdded, nil
+}

cmd/kaspawallet/daemon/server/split_transaction_test.go

@@ -0,0 +1,152 @@
+package server
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet/serialization"
+
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/keys"
+	"github.com/kaspanet/kaspad/util/txmass"
+
+	"github.com/kaspanet/kaspad/domain/dagconfig"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
+
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
+	"github.com/kaspanet/kaspad/domain/consensus"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
+)
+
+func TestEstimateMassAfterSignatures(t *testing.T) {
+	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
+		unsignedTransactionBytes, mnemonics, params, teardown := testEstimateMassIncreaseForSignaturesSetUp(t, consensusConfig)
+		defer teardown(false)
+
+		serverInstance := &server{
+			params:           params,
+			keysFile:         &keys.File{MinimumSignatures: 2},
+			shutdown:         make(chan struct{}),
+			addressSet:       make(walletAddressSet),
+			txMassCalculator: txmass.NewCalculator(params.MassPerTxByte, params.MassPerScriptPubKeyByte, params.MassPerSigOp),
+		}
+
+		unsignedTransaction, err := serialization.DeserializePartiallySignedTransaction(unsignedTransactionBytes)
+		if err != nil {
+			t.Fatalf("Error deserializing unsignedTransaction: %s", err)
+		}
+
+		estimatedMassAfterSignatures, err := serverInstance.estimateMassAfterSignatures(unsignedTransaction)
+		if err != nil {
+			t.Fatalf("Error from estimateMassAfterSignatures: %s", err)
+		}
+
+		signedTxStep1Bytes, err := libkaspawallet.Sign(params, mnemonics[:1], unsignedTransactionBytes, false)
+		if err != nil {
+			t.Fatalf("Sign: %+v", err)
+		}
+
+		signedTxStep2Bytes, err := libkaspawallet.Sign(params, mnemonics[1:2], signedTxStep1Bytes, false)
+		if err != nil {
+			t.Fatalf("Sign: %+v", err)
+		}
+
+		extractedSignedTx, err := libkaspawallet.ExtractTransaction(signedTxStep2Bytes, false)
+		if err != nil {
+			t.Fatalf("ExtractTransaction: %+v", err)
+		}
+
+		actualMassAfterSignatures := serverInstance.txMassCalculator.CalculateTransactionMass(extractedSignedTx)
+
+		if estimatedMassAfterSignatures != actualMassAfterSignatures {
+			t.Errorf("Estimated mass after signatures: %d but actually got %d",
+				estimatedMassAfterSignatures, actualMassAfterSignatures)
+		}
+	})
+}
+
+func testEstimateMassIncreaseForSignaturesSetUp(t *testing.T, consensusConfig *consensus.Config) (
+	[]byte, []string, *dagconfig.Params, func(keepDataDir bool)) {
+
+	consensusConfig.BlockCoinbaseMaturity = 0
+	params := &consensusConfig.Params
+
+	tc, teardown, err := consensus.NewFactory().NewTestConsensus(consensusConfig, "TestMultisig")
+	if err != nil {
+		t.Fatalf("Error setting up tc: %+v", err)
+	}
+
+	const numKeys = 3
+	mnemonics := make([]string, numKeys)
+	publicKeys := make([]string, numKeys)
+	for i := 0; i < numKeys; i++ {
+		var err error
+		mnemonics[i], err = libkaspawallet.CreateMnemonic()
+		if err != nil {
+			t.Fatalf("CreateMnemonic: %+v", err)
+		}
+
+		publicKeys[i], err = libkaspawallet.MasterPublicKeyFromMnemonic(&consensusConfig.Params, mnemonics[i], true)
+		if err != nil {
+			t.Fatalf("MasterPublicKeyFromMnemonic: %+v", err)
+		}
+	}
+
+	const minimumSignatures = 2
+	path := "m/1/2/3"
+	address, err := libkaspawallet.Address(params, publicKeys, minimumSignatures, path, false)
+	if err != nil {
+		t.Fatalf("Address: %+v", err)
+	}
+
+	scriptPublicKey, err := txscript.PayToAddrScript(address)
+	if err != nil {
+		t.Fatalf("PayToAddrScript: %+v", err)
+	}
+
+	coinbaseData := &externalapi.DomainCoinbaseData{
+		ScriptPublicKey: scriptPublicKey,
+		ExtraData:       nil,
+	}
+
+	fundingBlockHash, _, err := tc.AddBlock([]*externalapi.DomainHash{consensusConfig.GenesisHash}, coinbaseData, nil)
+	if err != nil {
+		t.Fatalf("AddBlock: %+v", err)
+	}
+
+	block1Hash, _, err := tc.AddBlock([]*externalapi.DomainHash{fundingBlockHash}, nil, nil)
+	if err != nil {
+		t.Fatalf("AddBlock: %+v", err)
+	}
+
+	block1, err := tc.GetBlock(block1Hash)
+	if err != nil {
+		t.Fatalf("GetBlock: %+v", err)
+	}
+
+	block1Tx := block1.Transactions[0]
+	block1TxOut := block1Tx.Outputs[0]
+	selectedUTXOs := []*libkaspawallet.UTXO{
+		{
+			Outpoint: &externalapi.DomainOutpoint{
+				TransactionID: *consensushashing.TransactionID(block1.Transactions[0]),
+				Index:         0,
+			},
+			UTXOEntry:      utxo.NewUTXOEntry(block1TxOut.Value, block1TxOut.ScriptPublicKey, true, 0),
+			DerivationPath: path,
+		},
+	}
+
+	unsignedTransaction, err := libkaspawallet.CreateUnsignedTransaction(publicKeys, minimumSignatures,
+		[]*libkaspawallet.Payment{{
+			Address: address,
+			Amount:  10,
+		}}, selectedUTXOs)
+	if err != nil {
+		t.Fatalf("CreateUnsignedTransactions: %+v", err)
+	}
+
+	return unsignedTransaction, mnemonics, params, teardown
+}

cmd/kaspawallet/libkaspawallet/serialization/serialization.go

@@ -34,6 +34,44 @@ type PubKeySignaturePair struct {
 	Signature         []byte
 }
 
+// Clone creates a deep-clone of this PartiallySignedTransaction
+func (pst *PartiallySignedTransaction) Clone() *PartiallySignedTransaction {
+	clone := &PartiallySignedTransaction{
+		Tx:                    pst.Tx.Clone(),
+		PartiallySignedInputs: make([]*PartiallySignedInput, len(pst.PartiallySignedInputs)),
+	}
+	for i, partiallySignedInput := range pst.PartiallySignedInputs {
+		clone.PartiallySignedInputs[i] = partiallySignedInput.Clone()
+	}
+	return clone
+}
+
+// Clone creates a deep-clone of this PartiallySignedInput
+func (psi PartiallySignedInput) Clone() *PartiallySignedInput {
+	clone := &PartiallySignedInput{
+		PrevOutput:           psi.PrevOutput.Clone(),
+		MinimumSignatures:    psi.MinimumSignatures,
+		PubKeySignaturePairs: make([]*PubKeySignaturePair, len(psi.PubKeySignaturePairs)),
+		DerivationPath:       psi.DerivationPath,
+	}
+	for i, pubKeySignaturePair := range psi.PubKeySignaturePairs {
+		clone.PubKeySignaturePairs[i] = pubKeySignaturePair.Clone()
+	}
+	return clone
+}
+
+// Clone creates a deep-clone of this PubKeySignaturePair
+func (psp PubKeySignaturePair) Clone() *PubKeySignaturePair {
+	clone := &PubKeySignaturePair{
+		ExtendedPublicKey: psp.ExtendedPublicKey,
+	}
+	if psp.Signature != nil {
+		clone.Signature = make([]byte, len(psp.Signature))
+		copy(clone.Signature, psp.Signature)
+	}
+	return clone
+}
+
 // DeserializePartiallySignedTransaction deserializes a byte slice into PartiallySignedTransaction.
 func DeserializePartiallySignedTransaction(serializedPartiallySignedTransaction []byte) (*PartiallySignedTransaction, error) {
 	protoPartiallySignedTransaction := &protoserialization.PartiallySignedTransaction{}

cmd/kaspawallet/libkaspawallet/sign.go

@@ -40,7 +40,6 @@ func Sign(params *dagconfig.Params, mnemonics []string, serializedPSTx []byte, e
 			return nil, err
 		}
 	}
-
 	return serialization.SerializePartiallySignedTransaction(partiallySignedTransaction)
 }
 

cmd/kaspawallet/libkaspawallet/transaction.go

@@ -159,6 +159,7 @@ func createUnsignedTransaction(
 		Tx:                    domainTransaction,
 		PartiallySignedInputs: partiallySignedInputs,
 	}, nil
+
 }
 
 // IsTransactionFullySigned returns whether the transaction is fully signed and ready to broadcast.
@@ -194,10 +195,14 @@ func ExtractTransaction(partiallySignedTransactionBytes []byte, ecdsa bool) (*ex
 		return nil, err
 	}
 
-	return extractTransaction(partiallySignedTransaction, ecdsa)
+	return ExtractTransactionDeserialized(partiallySignedTransaction, ecdsa)
 }
 
-func extractTransaction(partiallySignedTransaction *serialization.PartiallySignedTransaction, ecdsa bool) (*externalapi.DomainTransaction, error) {
+// ExtractTransactionDeserialized does the same thing ExtractTransaction does, only receives the PartiallySignedTransaction
+// in an already deserialized format
+func ExtractTransactionDeserialized(partiallySignedTransaction *serialization.PartiallySignedTransaction, ecdsa bool) (
+	*externalapi.DomainTransaction, error) {
+
 	for i, input := range partiallySignedTransaction.PartiallySignedInputs {
 		isMultisig := len(input.PubKeySignaturePairs) > 1
 		scriptBuilder := txscript.NewScriptBuilder()

cmd/kaspawallet/libkaspawallet/transaction_test.go

@@ -2,6 +2,9 @@ package libkaspawallet_test
 
 import (
 	"fmt"
+	"strings"
+	"testing"
+
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
 	"github.com/kaspanet/kaspad/domain/consensus"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@@ -10,8 +13,6 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
 	"github.com/kaspanet/kaspad/util"
-	"strings"
-	"testing"
 )
 
 func forSchnorrAndECDSA(t *testing.T, testFunc func(t *testing.T, ecdsa bool)) {
@@ -106,7 +107,7 @@ func TestMultisig(t *testing.T) {
 					Amount:  10,
 				}}, selectedUTXOs)
 			if err != nil {
-				t.Fatalf("CreateUnsignedTransaction: %+v", err)
+				t.Fatalf("CreateUnsignedTransactions: %+v", err)
 			}
 
 			isFullySigned, err := libkaspawallet.IsTransactionFullySigned(unsignedTransaction)
@@ -267,7 +268,7 @@ func TestP2PK(t *testing.T) {
 					Amount:  10,
 				}}, selectedUTXOs)
 			if err != nil {
-				t.Fatalf("CreateUnsignedTransaction: %+v", err)
+				t.Fatalf("CreateUnsignedTransactions: %+v", err)
 			}
 
 			isFullySigned, err := libkaspawallet.IsTransactionFullySigned(unsignedTransaction)

cmd/kaspawallet/send.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
+
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/keys"
@@ -31,10 +32,11 @@ func send(conf *sendConfig) error {
 	defer cancel()
 
 	sendAmountSompi := uint64(conf.SendAmount * constants.SompiPerKaspa)
-	createUnsignedTransactionResponse, err := daemonClient.CreateUnsignedTransaction(ctx, &pb.CreateUnsignedTransactionRequest{
-		Address: conf.ToAddress,
-		Amount:  sendAmountSompi,
-	})
+	createUnsignedTransactionsResponse, err :=
+		daemonClient.CreateUnsignedTransactions(ctx, &pb.CreateUnsignedTransactionsRequest{
+			Address: conf.ToAddress,
+			Amount:  sendAmountSompi,
+		})
 	if err != nil {
 		return err
 	}
@@ -44,22 +46,37 @@ func send(conf *sendConfig) error {
 		return err
 	}
 
-	signedTransaction, err := libkaspawallet.Sign(conf.NetParams(), mnemonics, createUnsignedTransactionResponse.UnsignedTransaction, keysFile.ECDSA)
-	if err != nil {
-		return err
+	signedTransactions := make([][]byte, len(createUnsignedTransactionsResponse.UnsignedTransactions))
+	for i, unsignedTransaction := range createUnsignedTransactionsResponse.UnsignedTransactions {
+		signedTransaction, err := libkaspawallet.Sign(conf.NetParams(), mnemonics, unsignedTransaction, keysFile.ECDSA)
+		if err != nil {
+			return err
+		}
+		signedTransactions[i] = signedTransaction
 	}
 
-	ctx2, cancel2 := context.WithTimeout(context.Background(), daemonTimeout)
-	defer cancel2()
-	broadcastResponse, err := daemonClient.Broadcast(ctx2, &pb.BroadcastRequest{
-		Transaction: signedTransaction,
-	})
-	if err != nil {
-		return err
+	if len(signedTransactions) > 1 {
+		fmt.Printf("Broadcasting %d transactions\n", len(signedTransactions))
 	}
+	for _, signedTransaction := range signedTransactions {
+		err := func() error { // surround with func so that defer runs separately per transaction
+			ctx2, cancel2 := context.WithTimeout(context.Background(), daemonTimeout)
+			defer cancel2()
+			broadcastResponse, err := daemonClient.Broadcast(ctx2, &pb.BroadcastRequest{
+				Transaction: signedTransaction,
+			})
+			if err != nil {
+				return err
+			}
 
-	fmt.Println("Transaction was sent successfully")
-	fmt.Printf("Transaction ID: \t%s\n", broadcastResponse.TxID)
+			fmt.Println("Transaction was sent successfully")
+			fmt.Printf("Transaction ID: \t%s\n", broadcastResponse.TxID)
+			return nil
+		}()
+		if err != nil {
+			return err
+		}
+	}
 
 	return nil
 }

cmd/kaspawallet/sign.go

@@ -1,21 +1,16 @@
 package main
 
 import (
-	"encoding/hex"
 	"fmt"
+	"io/ioutil"
+	"strings"
+
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/keys"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
 	"github.com/pkg/errors"
-	"io/ioutil"
-	"strings"
 )
 
 func sign(conf *signConfig) error {
-	keysFile, err := keys.ReadKeysFile(conf.NetParams(), conf.KeysFile)
-	if err != nil {
-		return err
-	}
-
 	if conf.Transaction == "" && conf.TransactionFile == "" {
 		return errors.Errorf("Either --transaction or --transaction-file is required")
 	}
@@ -23,41 +18,56 @@ func sign(conf *signConfig) error {
 		return errors.Errorf("Both --transaction and --transaction-file cannot be passed at the same time")
 	}
 
-	transactionHex := conf.Transaction
-	if conf.TransactionFile != "" {
-		transactionHexBytes, err := ioutil.ReadFile(conf.TransactionFile)
-		if err != nil {
-			return errors.Wrapf(err, "Could not read hex from %s", conf.TransactionFile)
-		}
-		transactionHex = strings.TrimSpace(string(transactionHexBytes))
-	}
-
-	partiallySignedTransaction, err := hex.DecodeString(transactionHex)
+	keysFile, err := keys.ReadKeysFile(conf.NetParams(), conf.KeysFile)
 	if err != nil {
 		return err
 	}
-
 	privateKeys, err := keysFile.DecryptMnemonics(conf.Password)
 	if err != nil {
 		return err
 	}
 
-	updatedPartiallySignedTransaction, err := libkaspawallet.Sign(conf.NetParams(), privateKeys, partiallySignedTransaction, keysFile.ECDSA)
+	transactionsHex := conf.Transaction
+	if conf.TransactionFile != "" {
+		transactionHexBytes, err := ioutil.ReadFile(conf.TransactionFile)
+		if err != nil {
+			return errors.Wrapf(err, "Could not read hex from %s", conf.TransactionFile)
+		}
+		transactionsHex = strings.TrimSpace(string(transactionHexBytes))
+	}
+	partiallySignedTransactions, err := decodeTransactionsFromHex(transactionsHex)
 	if err != nil {
 		return err
 	}
 
-	isFullySigned, err := libkaspawallet.IsTransactionFullySigned(updatedPartiallySignedTransaction)
-	if err != nil {
-		return err
+	updatedPartiallySignedTransactions := make([][]byte, len(partiallySignedTransactions))
+	for i, partiallySignedTransaction := range partiallySignedTransactions {
+		updatedPartiallySignedTransactions[i], err =
+			libkaspawallet.Sign(conf.NetParams(), privateKeys, partiallySignedTransaction, keysFile.ECDSA)
+		if err != nil {
+			return err
+		}
 	}
 
-	if isFullySigned {
+	areAllTransactionsFullySigned := true
+	for _, updatedPartiallySignedTransaction := range updatedPartiallySignedTransactions {
+		// This is somewhat redundant to check all transactions, but we do that just-in-case
+		isFullySigned, err := libkaspawallet.IsTransactionFullySigned(updatedPartiallySignedTransaction)
+		if err != nil {
+			return err
+		}
+		if !isFullySigned {
+			areAllTransactionsFullySigned = false
+		}
+	}
+
+	if areAllTransactionsFullySigned {
 		fmt.Println("The transaction is signed and ready to broadcast")
 	} else {
 		fmt.Println("Successfully signed transaction")
 	}
 
-	fmt.Printf("Transaction: %x\n", updatedPartiallySignedTransaction)
+	fmt.Println("Transaction: ")
+	fmt.Println(encodeTransactionsToHex(updatedPartiallySignedTransactions))
 	return nil
 }

cmd/kaspawallet/transactions_hex_encoding.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"encoding/hex"
+	"strings"
+)
+
+// hexTransactionsSeparator is used to mark the end of one transaction and the beginning of the next one.
+// We use a separator that is not in the hex alphabet, but which will not split selection with a double click
+const hexTransactionsSeparator = "_"
+
+func encodeTransactionsToHex(transactions [][]byte) string {
+	transactionsInHex := make([]string, len(transactions))
+	for i, transaction := range transactions {
+		transactionsInHex[i] = hex.EncodeToString(transaction)
+	}
+	return strings.Join(transactionsInHex, hexTransactionsSeparator)
+}
+
+func decodeTransactionsFromHex(transactionsHex string) ([][]byte, error) {
+	splitTransactionsHexes := strings.Split(transactionsHex, hexTransactionsSeparator)
+	transactions := make([][]byte, len(splitTransactionsHexes))
+
+	var err error
+	for i, transactionHex := range splitTransactionsHexes {
+		transactions[i], err = hex.DecodeString(transactionHex)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return transactions, nil
+}

docker/Dockerfile

@@ -1,5 +1,5 @@
 # -- multistage docker build: stage #1: build stage
-FROM golang:1.16-alpine AS build
+FROM golang:1.18-alpine AS build
 
 RUN mkdir -p /go/src/github.com/kaspanet/kaspad
 

domain/consensus/consensus.go

@@ -1,8 +1,6 @@
 package consensus
 
 import (
-	"github.com/kaspanet/kaspad/infrastructure/logger"
-	"github.com/kaspanet/kaspad/util/staging"
 	"math/big"
 	"sync"
 
@@ -10,6 +8,8 @@ import (
 	"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/infrastructure/logger"
+	"github.com/kaspanet/kaspad/util/staging"
 	"github.com/pkg/errors"
 )
 
@@ -35,7 +35,7 @@ type consensus struct {
 	headerTipsManager     model.HeadersSelectedTipManager
 	mergeDepthManager     model.MergeDepthManager
 	pruningManager        model.PruningManager
-	reachabilityManagers  []model.ReachabilityManager
+	reachabilityManager   model.ReachabilityManager
 	finalityManager       model.FinalityManager
 	pruningProofManager   model.PruningProofManager
 
@@ -49,7 +49,7 @@ type consensus struct {
 	consensusStateStore                 model.ConsensusStateStore
 	headersSelectedTipStore             model.HeaderSelectedTipStore
 	multisetStore                       model.MultisetStore
-	reachabilityDataStores              []model.ReachabilityDataStore
+	reachabilityDataStore               model.ReachabilityDataStore
 	utxoDiffStore                       model.UTXODiffStore
 	finalityStore                       model.FinalityStore
 	headersSelectedChainStore           model.HeadersSelectedChainStore
@@ -83,11 +83,9 @@ func (s *consensus) Init(skipAddingGenesis bool) error {
 	// on a node with pruned header all blocks without known parents points to it.
 	if !exists {
 		s.blockStatusStore.Stage(stagingArea, model.VirtualGenesisBlockHash, externalapi.StatusUTXOValid)
-		for _, reachabilityManager := range s.reachabilityManagers {
-			err = reachabilityManager.Init(stagingArea)
-			if err != nil {
-				return err
-			}
+		err = s.reachabilityManager.Init(stagingArea)
+		if err != nil {
+			return err
 		}
 
 		for _, dagTopologyManager := range s.dagTopologyManagers {
@@ -152,6 +150,18 @@ func (s *consensus) BuildBlock(coinbaseData *externalapi.DomainCoinbaseData,
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
+	block, _, err := s.blockBuilder.BuildBlock(coinbaseData, transactions)
+	return block, err
+}
+
+// BuildBlockWithTemplateMetadata builds a block over the current state, with the transactions
+// selected by the given transactionSelector plus metadata information related to coinbase rewards
+func (s *consensus) BuildBlockWithTemplateMetadata(coinbaseData *externalapi.DomainCoinbaseData,
+	transactions []*externalapi.DomainTransaction) (block *externalapi.DomainBlock, coinbaseHasRedReward bool, err error) {
+
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
 	return s.blockBuilder.BuildBlock(coinbaseData, transactions)
 }
 
@@ -343,6 +353,25 @@ func (s *consensus) GetHashesBetween(lowHash, highHash *externalapi.DomainHash,
 	return s.syncManager.GetHashesBetween(stagingArea, lowHash, highHash, maxBlocks)
 }
 
+func (s *consensus) GetAnticone(blockHash, contextHash *externalapi.DomainHash,
+	maxBlocks uint64) (hashes []*externalapi.DomainHash, err error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	stagingArea := model.NewStagingArea()
+
+	err = s.validateBlockHashExists(stagingArea, blockHash)
+	if err != nil {
+		return nil, err
+	}
+	err = s.validateBlockHashExists(stagingArea, contextHash)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.syncManager.GetAnticone(stagingArea, blockHash, contextHash, maxBlocks)
+}
+
 func (s *consensus) GetMissingBlockBodyHashes(highHash *externalapi.DomainHash) ([]*externalapi.DomainHash, error) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -701,7 +730,7 @@ func (s *consensus) Anticone(blockHash *externalapi.DomainHash) ([]*externalapi.
 		return nil, err
 	}
 
-	return s.dagTraversalManager.AnticoneFromBlocks(stagingArea, tips, blockHash)
+	return s.dagTraversalManager.AnticoneFromBlocks(stagingArea, tips, blockHash, 0)
 }
 
 func (s *consensus) EstimateNetworkHashesPerSecond(startHash *externalapi.DomainHash, windowSize int) (uint64, error) {
@@ -721,7 +750,25 @@ func (s *consensus) ResolveVirtual() (*externalapi.VirtualChangeSet, bool, error
 
 	// In order to prevent a situation that the consensus lock is held for too much time, we
 	// release the lock each time resolve 100 blocks.
-	return s.consensusStateManager.ResolveVirtual(100)
+	// Note: maxBlocksToResolve should be smaller than finality interval in order to avoid a situation
+	// where UpdatePruningPointByVirtual skips a pruning point.
+	virtualChangeSet, isCompletelyResolved, err := s.consensusStateManager.ResolveVirtual(100)
+	if err != nil {
+		return nil, false, err
+	}
+
+	stagingArea := model.NewStagingArea()
+	err = s.pruningManager.UpdatePruningPointByVirtual(stagingArea)
+	if err != nil {
+		return nil, false, err
+	}
+
+	err = staging.CommitAllChanges(s.databaseContext, stagingArea)
+	if err != nil {
+		return nil, false, err
+	}
+
+	return virtualChangeSet, isCompletelyResolved, nil
 }
 
 func (s *consensus) BuildPruningPointProof() (*externalapi.PruningPointProof, error) {

domain/consensus/datastructures/blockrelationstore/block_relation_store.go

@@ -75,6 +75,11 @@ func (brs *blockRelationStore) Has(dbContext model.DBReader, stagingArea *model.
 	return dbContext.Has(brs.hashAsKey(blockHash))
 }
 
+func (brs *blockRelationStore) UnstageAll(stagingArea *model.StagingArea) {
+	stagingShard := brs.stagingShard(stagingArea)
+	stagingShard.toAdd = make(map[externalapi.DomainHash]*model.BlockRelations)
+}
+
 func (brs *blockRelationStore) hashAsKey(hash *externalapi.DomainHash) model.DBKey {
 	return brs.bucket.Key(hash.ByteSlice())
 }

domain/consensus/datastructures/ghostdagdatastore/ghostdag_data_store.go

@@ -69,6 +69,12 @@ func (gds *ghostdagDataStore) Get(dbContext model.DBReader, stagingArea *model.S
 	return blockGHOSTDAGData, nil
 }
 
+func (gds *ghostdagDataStore) UnstageAll(stagingArea *model.StagingArea) {
+	stagingShard := gds.stagingShard(stagingArea)
+
+	stagingShard.toAdd = make(map[key]*externalapi.BlockGHOSTDAGData)
+}
+
 func (gds *ghostdagDataStore) serializeKey(k key) model.DBKey {
 	if k.isTrustedData {
 		return gds.trustedDataBucket.Key(k.hash.ByteSlice())

domain/consensus/datastructures/pruningstore/pruning_store.go

@@ -10,6 +10,7 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/lrucacheuint64tohash"
 	"github.com/kaspanet/kaspad/util/staging"
+	"github.com/pkg/errors"
 )
 
 var currentPruningPointIndexKeyName = []byte("pruning-block-index")
@@ -298,11 +299,17 @@ func (ps *pruningStore) StagePruningPointByIndex(dbContext model.DBReader, stagi
 	pruningPointBlockHash *externalapi.DomainHash, index uint64) error {
 
 	stagingShard := ps.stagingShard(stagingArea)
+	_, exists := stagingShard.pruningPointByIndex[index]
+	if exists {
+		return errors.Errorf("%s is already staged for pruning point with index %d", stagingShard.pruningPointByIndex[index], index)
+	}
+
 	stagingShard.pruningPointByIndex[index] = pruningPointBlockHash
 
 	pruningPointIndex, err := ps.CurrentPruningPointIndex(dbContext, stagingArea)
 	isNotFoundError := database.IsNotFoundError(err)
 	if !isNotFoundError && err != nil {
+		delete(stagingShard.pruningPointByIndex, index)
 		return err
 	}
 

domain/consensus/datastructures/reachabilitydatastore/reachability_data_store.go

@@ -41,6 +41,27 @@ func (rds *reachabilityDataStore) StageReachabilityData(stagingArea *model.Stagi
 	stagingShard.reachabilityData[*blockHash] = reachabilityData
 }
 
+func (rds *reachabilityDataStore) Delete(dbContext model.DBWriter) error {
+	cursor, err := dbContext.Cursor(rds.reachabilityDataBucket)
+	if err != nil {
+		return err
+	}
+
+	for ok := cursor.First(); ok; ok = cursor.Next() {
+		key, err := cursor.Key()
+		if err != nil {
+			return err
+		}
+
+		err = dbContext.Delete(key)
+		if err != nil {
+			return err
+		}
+	}
+
+	return dbContext.Delete(rds.reachabilityReindexRootKey)
+}
+
 // StageReachabilityReindexRoot stages the given reachabilityReindexRoot
 func (rds *reachabilityDataStore) StageReachabilityReindexRoot(stagingArea *model.StagingArea, reachabilityReindexRoot *externalapi.DomainHash) {
 	stagingShard := rds.stagingShard(stagingArea)

domain/consensus/factory.go

@@ -7,11 +7,14 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/processes/blockparentbuilder"
 	parentssanager "github.com/kaspanet/kaspad/domain/consensus/processes/parentsmanager"
 	"github.com/kaspanet/kaspad/domain/consensus/processes/pruningproofmanager"
+	"github.com/kaspanet/kaspad/util/staging"
+	"github.com/pkg/errors"
 	"io/ioutil"
 	"os"
 	"sync"
 
 	"github.com/kaspanet/kaspad/domain/prefixmanager/prefix"
+	"github.com/kaspanet/kaspad/util/txmass"
 
 	consensusdatabase "github.com/kaspanet/kaspad/domain/consensus/database"
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/acceptancedatastore"
@@ -73,7 +76,7 @@ type Config struct {
 // Factory instantiates new Consensuses
 type Factory interface {
 	NewConsensus(config *Config, db infrastructuredatabase.Database, dbPrefix *prefix.Prefix) (
-		externalapi.Consensus, error)
+		externalapi.Consensus, bool, error)
 	NewTestConsensus(config *Config, testName string) (
 		tc testapi.TestConsensus, teardown func(keepDataDir bool), err error)
 
@@ -105,7 +108,7 @@ func NewFactory() Factory {
 
 // NewConsensus instantiates a new Consensus
 func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Database, dbPrefix *prefix.Prefix) (
-	externalapi.Consensus, error) {
+	consensusInstance externalapi.Consensus, shouldMigrate bool, err error) {
 
 	dbManager := consensusdatabase.New(db)
 	prefixBucket := consensusdatabase.MakeBucket(dbPrefix.Serialize())
@@ -128,11 +131,11 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 	acceptanceDataStore := acceptancedatastore.New(prefixBucket, 200, preallocateCaches)
 	blockStore, err := blockstore.New(dbManager, prefixBucket, 200, preallocateCaches)
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 	blockHeaderStore, err := blockheaderstore.New(dbManager, prefixBucket, 10_000, preallocateCaches)
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 
 	blockStatusStore := blockstatusstore.New(prefixBucket, pruningWindowSizePlusFinalityDepthForCache, preallocateCaches)
@@ -147,11 +150,35 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 	daaBlocksStore := daablocksstore.New(prefixBucket, pruningWindowSizeForCaches, int(config.FinalityDepth()), preallocateCaches)
 	windowHeapSliceStore := blockwindowheapslicestore.New(2000, preallocateCaches)
 
+	newReachabilityDataStore := reachabilitydatastore.New(prefixBucket, pruningWindowSizePlusFinalityDepthForCache*2, preallocateCaches)
 	blockRelationStores, reachabilityDataStores, ghostdagDataStores := dagStores(config, prefixBucket, pruningWindowSizePlusFinalityDepthForCache, pruningWindowSizeForCaches, preallocateCaches)
-	reachabilityManagers, dagTopologyManagers, ghostdagManagers, dagTraversalManagers := f.dagProcesses(config, dbManager, blockHeaderStore, daaWindowStore, windowHeapSliceStore, blockRelationStores, reachabilityDataStores, ghostdagDataStores)
+	oldReachabilityManager := reachabilitymanager.New(
+		dbManager,
+		ghostdagDataStores[0],
+		reachabilityDataStores[0])
+	isOldReachabilityInitialized, err := reachabilityDataStores[0].HasReachabilityData(dbManager, model.NewStagingArea(), model.VirtualGenesisBlockHash)
+	if err != nil {
+		return nil, false, err
+	}
+
+	newReachabilityManager := reachabilitymanager.New(
+		dbManager,
+		ghostdagDataStores[0],
+		newReachabilityDataStore)
+	reachabilityManager := newReachabilityManager
+	if isOldReachabilityInitialized {
+		reachabilityManager = oldReachabilityManager
+	} else {
+		for i := range reachabilityDataStores {
+			reachabilityDataStores[i] = newReachabilityDataStore
+		}
+	}
+	reachabilityDataStore := reachabilityDataStores[0]
+
+	dagTopologyManagers, ghostdagManagers, dagTraversalManagers := f.dagProcesses(config, dbManager, blockHeaderStore, daaWindowStore, windowHeapSliceStore, blockRelationStores, reachabilityDataStores, ghostdagDataStores, isOldReachabilityInitialized)
 
 	blockRelationStore := blockRelationStores[0]
-	reachabilityDataStore := reachabilityDataStores[0]
+
 	ghostdagDataStore := ghostdagDataStores[0]
 
 	dagTopologyManager := dagTopologyManagers[0]
@@ -171,6 +198,9 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		config.GenesisHash,
 		config.MaxBlockLevel,
 	)
+
+	txMassCalculator := txmass.NewCalculator(config.MassPerTxByte, config.MassPerScriptPubKeyByte, config.MassPerSigOp)
+
 	pastMedianTimeManager := f.pastMedianTimeConsructor(
 		config.TimestampDeviationTolerance,
 		dbManager,
@@ -180,14 +210,12 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		config.GenesisHash)
 	transactionValidator := transactionvalidator.New(config.BlockCoinbaseMaturity,
 		config.EnableNonNativeSubnetworks,
-		config.MassPerTxByte,
-		config.MassPerScriptPubKeyByte,
-		config.MassPerSigOp,
 		config.MaxCoinbasePayloadLength,
 		dbManager,
 		pastMedianTimeManager,
 		ghostdagDataStore,
-		daaBlocksStore)
+		daaBlocksStore,
+		txMassCalculator)
 	difficultyManager := f.difficultyConstructor(
 		dbManager,
 		ghostdagManager,
@@ -225,6 +253,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		dagTopologyManager,
 		finalityStore,
 		ghostdagDataStore,
+		pruningStore,
 		genesisHash,
 		config.FinalityDepth())
 	mergeDepthManager := mergedepthmanager.New(
@@ -262,7 +291,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		pruningStore,
 		daaBlocksStore)
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 
 	pruningManager := pruningmanager.New(
@@ -317,7 +346,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		dagTraversalManager,
 		coinbaseManager,
 		mergeDepthManager,
-		reachabilityManagers,
+		reachabilityManager,
 		finalityManager,
 		blockParentBuilder,
 		pruningManager,
@@ -331,6 +360,8 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		reachabilityDataStore,
 		consensusStateStore,
 		daaBlocksStore,
+
+		txMassCalculator,
 	)
 
 	syncManager := syncmanager.New(
@@ -379,7 +410,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		pruningManager,
 		blockValidator,
 		dagTopologyManager,
-		reachabilityManagers,
+		reachabilityManager,
 		difficultyManager,
 		pastMedianTimeManager,
 		coinbaseManager,
@@ -407,9 +438,10 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		dbManager,
 		dagTopologyManagers,
 		ghostdagManagers,
-		reachabilityManagers,
+		reachabilityManager,
 		dagTraversalManagers,
 		parentsManager,
+		pruningManager,
 
 		ghostdagDataStores,
 		pruningStore,
@@ -417,6 +449,8 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		blockStatusStore,
 		finalityStore,
 		consensusStateStore,
+		blockRelationStore,
+		reachabilityDataStore,
 
 		genesisHash,
 		config.K,
@@ -446,7 +480,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		headerTipsManager:     headerTipsManager,
 		mergeDepthManager:     mergeDepthManager,
 		pruningManager:        pruningManager,
-		reachabilityManagers:  reachabilityManagers,
+		reachabilityManager:   reachabilityManager,
 		finalityManager:       finalityManager,
 		pruningProofManager:   pruningProofManager,
 
@@ -460,7 +494,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		consensusStateStore:                 consensusStateStore,
 		headersSelectedTipStore:             headersSelectedTipStore,
 		multisetStore:                       multisetStore,
-		reachabilityDataStores:              reachabilityDataStores,
+		reachabilityDataStore:               reachabilityDataStore,
 		utxoDiffStore:                       utxoDiffStore,
 		finalityStore:                       finalityStore,
 		headersSelectedChainStore:           headersSelectedChainStore,
@@ -468,25 +502,40 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		blocksWithTrustedDataDAAWindowStore: daaWindowStore,
 	}
 
+	if isOldReachabilityInitialized {
+		return c, true, nil
+	}
+
 	err = c.Init(config.SkipAddingGenesis)
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 
 	err = consensusStateManager.RecoverUTXOIfRequired()
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 	err = pruningManager.ClearImportedPruningPointData()
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 	err = pruningManager.UpdatePruningPointIfRequired()
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 
-	return c, nil
+	stagingArea := model.NewStagingArea()
+	err = pruningManager.UpdatePruningPointByVirtual(stagingArea)
+	if err != nil {
+		return nil, false, err
+	}
+
+	err = staging.CommitAllChanges(dbManager, stagingArea)
+	if err != nil {
+		return nil, false, err
+	}
+
+	return c, false, nil
 }
 
 func (f *factory) NewTestConsensus(config *Config, testName string) (
@@ -513,11 +562,15 @@ func (f *factory) NewTestConsensus(config *Config, testName string) (
 	}
 
 	testConsensusDBPrefix := &prefix.Prefix{}
-	consensusAsInterface, err := f.NewConsensus(config, db, testConsensusDBPrefix)
+	consensusAsInterface, shouldMigrate, err := f.NewConsensus(config, db, testConsensusDBPrefix)
 	if err != nil {
 		return nil, nil, err
 	}
 
+	if shouldMigrate {
+		return nil, nil, errors.Errorf("A fresh consensus should never return shouldMigrate=true")
+	}
+
 	consensusAsImplementation := consensusAsInterface.(*consensus)
 	testConsensusStateManager := consensusstatemanager.NewTestConsensusStateManager(consensusAsImplementation.consensusStateManager)
 	testTransactionValidator := transactionvalidator.NewTestTransactionValidator(consensusAsImplementation.transactionValidator)
@@ -528,7 +581,7 @@ func (f *factory) NewTestConsensus(config *Config, testName string) (
 		database:                  db,
 		testConsensusStateManager: testConsensusStateManager,
 		testReachabilityManager: reachabilitymanager.NewTestReachabilityManager(consensusAsImplementation.
-			reachabilityManagers[0]),
+			reachabilityManager),
 		testTransactionValidator: testTransactionValidator,
 	}
 	tstConsensus.testBlockBuilder = blockbuilder.NewTestBlockBuilder(consensusAsImplementation.blockBuilder, tstConsensus)
@@ -605,8 +658,8 @@ func (f *factory) dagProcesses(config *Config,
 	windowHeapSliceStore model.WindowHeapSliceStore,
 	blockRelationStores []model.BlockRelationStore,
 	reachabilityDataStores []model.ReachabilityDataStore,
-	ghostdagDataStores []model.GHOSTDAGDataStore) (
-	[]model.ReachabilityManager,
+	ghostdagDataStores []model.GHOSTDAGDataStore,
+	isOldReachabilityInitialized bool) (
 	[]model.DAGTopologyManager,
 	[]model.GHOSTDAGManager,
 	[]model.DAGTraversalManager,
@@ -617,11 +670,20 @@ func (f *factory) dagProcesses(config *Config,
 	ghostdagManagers := make([]model.GHOSTDAGManager, config.MaxBlockLevel+1)
 	dagTraversalManagers := make([]model.DAGTraversalManager, config.MaxBlockLevel+1)
 
+	newReachabilityManager := reachabilitymanager.New(
+		dbManager,
+		ghostdagDataStores[0],
+		reachabilityDataStores[0])
+
 	for i := 0; i <= config.MaxBlockLevel; i++ {
-		reachabilityManagers[i] = reachabilitymanager.New(
-			dbManager,
-			ghostdagDataStores[i],
-			reachabilityDataStores[i])
+		if isOldReachabilityInitialized {
+			reachabilityManagers[i] = reachabilitymanager.New(
+				dbManager,
+				ghostdagDataStores[i],
+				reachabilityDataStores[i])
+		} else {
+			reachabilityManagers[i] = newReachabilityManager
+		}
 
 		dagTopologyManagers[i] = dagtopologymanager.New(
 			dbManager,
@@ -641,7 +703,7 @@ func (f *factory) dagProcesses(config *Config,
 			dbManager,
 			dagTopologyManagers[i],
 			ghostdagDataStores[i],
-			reachabilityDataStores[i],
+			reachabilityManagers[i],
 			ghostdagManagers[i],
 			daaWindowStore,
 			windowHeapSliceStore,
@@ -649,5 +711,5 @@ func (f *factory) dagProcesses(config *Config,
 			config.DifficultyAdjustmentWindowSize)
 	}
 
-	return reachabilityManagers, dagTopologyManagers, ghostdagManagers, dagTraversalManagers
+	return dagTopologyManagers, ghostdagManagers, dagTraversalManagers
 }

domain/consensus/factory_test.go

@@ -24,8 +24,12 @@ func TestNewConsensus(t *testing.T) {
 		t.Fatalf("error in NewLevelDB: %s", err)
 	}
 
-	_, err = f.NewConsensus(config, db, &prefix.Prefix{})
+	_, shouldMigrate, err := f.NewConsensus(config, db, &prefix.Prefix{})
 	if err != nil {
 		t.Fatalf("error in NewConsensus: %+v", err)
 	}
+
+	if shouldMigrate {
+		t.Fatalf("A fresh consensus should never return shouldMigrate=true")
+	}
 }

domain/consensus/model/errors.go

@@ -5,3 +5,7 @@ import "github.com/pkg/errors"
 // ErrBlockNotInSelectedParentChain is returned from CreateHeadersSelectedChainBlockLocator if one of the parameters
 // passed to it are not in the headers selected parent chain
 var ErrBlockNotInSelectedParentChain = errors.New("Block is not in selected parent chain")
+
+// ErrReachedMaxTraversalAllowed is returned from AnticoneFromBlocks if `maxTraversalAllowed` was specified
+// and the traversal passed it
+var ErrReachedMaxTraversalAllowed = errors.New("Traversal searching for anticone passed the maxTraversalAllowed limit")

domain/consensus/model/externalapi/block.go

@@ -80,4 +80,5 @@ type MutableBlockHeader interface {
 	ToImmutable() BlockHeader
 	SetNonce(nonce uint64)
 	SetTimeInMilliseconds(timeInMilliseconds int64)
+	SetHashMerkleRoot(hashMerkleRoot *DomainHash)
 }

domain/consensus/model/externalapi/blocktemplate.go

@@ -0,0 +1,17 @@
+package externalapi
+
+// DomainBlockTemplate contains a Block plus metadata related to its generation
+type DomainBlockTemplate struct {
+	Block                *DomainBlock
+	CoinbaseData         *DomainCoinbaseData
+	CoinbaseHasRedReward bool
+}
+
+// Clone returns a clone of DomainBlockTemplate
+func (bt *DomainBlockTemplate) Clone() *DomainBlockTemplate {
+	return &DomainBlockTemplate{
+		Block:                bt.Block.Clone(),
+		CoinbaseData:         bt.CoinbaseData.Clone(),
+		CoinbaseHasRedReward: bt.CoinbaseHasRedReward,
+	}
+}

domain/consensus/model/externalapi/coinbase.go

@@ -1,5 +1,7 @@
 package externalapi
 
+import "bytes"
+
 // DomainCoinbaseData contains data by which a coinbase transaction
 // is built
 type DomainCoinbaseData struct {
@@ -21,3 +23,16 @@ func (dcd *DomainCoinbaseData) Clone() *DomainCoinbaseData {
 		ExtraData:       extraDataClone,
 	}
 }
+
+// Equal returns whether dcd equals to other
+func (dcd *DomainCoinbaseData) Equal(other *DomainCoinbaseData) bool {
+	if dcd == nil || other == nil {
+		return dcd == other
+	}
+
+	if !bytes.Equal(dcd.ExtraData, other.ExtraData) {
+		return false
+	}
+
+	return dcd.ScriptPublicKey.Equal(other.ScriptPublicKey)
+}

domain/consensus/model/externalapi/consensus.go

@@ -4,6 +4,7 @@ package externalapi
 type Consensus interface {
 	Init(skipAddingGenesis bool) error
 	BuildBlock(coinbaseData *DomainCoinbaseData, transactions []*DomainTransaction) (*DomainBlock, error)
+	BuildBlockWithTemplateMetadata(coinbaseData *DomainCoinbaseData, transactions []*DomainTransaction) (block *DomainBlock, coinbaseHasRedReward bool, err error)
 	ValidateAndInsertBlock(block *DomainBlock, shouldValidateAgainstUTXO bool) (*VirtualChangeSet, error)
 	ValidateAndInsertBlockWithTrustedData(block *BlockWithTrustedData, validateUTXO bool) (*VirtualChangeSet, error)
 	ValidateTransactionAndPopulateWithConsensusData(transaction *DomainTransaction) error
@@ -20,6 +21,7 @@ type Consensus interface {
 	GetBlockAcceptanceData(blockHash *DomainHash) (AcceptanceData, error)
 
 	GetHashesBetween(lowHash, highHash *DomainHash, maxBlocks uint64) (hashes []*DomainHash, actualHighHash *DomainHash, err error)
+	GetAnticone(blockHash, contextHash *DomainHash, maxBlocks uint64) (hashes []*DomainHash, err error)
 	GetMissingBlockBodyHashes(highHash *DomainHash) ([]*DomainHash, error)
 	GetPruningPointUTXOs(expectedPruningPointHash *DomainHash, fromOutpoint *DomainOutpoint, limit int) ([]*OutpointAndUTXOEntryPair, error)
 	GetVirtualUTXOs(expectedVirtualParents []*DomainHash, fromOutpoint *DomainOutpoint, limit int) ([]*OutpointAndUTXOEntryPair, error)

domain/consensus/model/externalapi/transaction.go

@@ -229,6 +229,19 @@ type ScriptPublicKey struct {
 	Version uint16
 }
 
+// Equal returns whether spk equals to other
+func (spk *ScriptPublicKey) Equal(other *ScriptPublicKey) bool {
+	if spk == nil || other == nil {
+		return spk == other
+	}
+
+	if spk.Version != other.Version {
+		return false
+	}
+
+	return bytes.Equal(spk.Script, other.Script)
+}
+
 // DomainTransactionOutput represents a Kaspad transaction output
 type DomainTransactionOutput struct {
 	Value           uint64
@@ -249,11 +262,7 @@ func (output *DomainTransactionOutput) Equal(other *DomainTransactionOutput) boo
 		return false
 	}
 
-	if !bytes.Equal(output.ScriptPublicKey.Script, other.ScriptPublicKey.Script) {
-		return false
-	}
-
-	return true
+	return output.ScriptPublicKey.Equal(other.ScriptPublicKey)
 }
 
 // Clone returns a clone of DomainTransactionOutput

domain/consensus/model/interface_datastructures_blockrelationstore.go

@@ -9,4 +9,5 @@ type BlockRelationStore interface {
 	IsStaged(stagingArea *StagingArea) bool
 	BlockRelation(dbContext DBReader, stagingArea *StagingArea, blockHash *externalapi.DomainHash) (*BlockRelations, error)
 	Has(dbContext DBReader, stagingArea *StagingArea, blockHash *externalapi.DomainHash) (bool, error)
+	UnstageAll(stagingArea *StagingArea)
 }

domain/consensus/model/interface_datastructures_ghostdagdatastore.go

@@ -8,4 +8,5 @@ type GHOSTDAGDataStore interface {
 	Stage(stagingArea *StagingArea, blockHash *externalapi.DomainHash, blockGHOSTDAGData *externalapi.BlockGHOSTDAGData, isTrustedData bool)
 	IsStaged(stagingArea *StagingArea) bool
 	Get(dbContext DBReader, stagingArea *StagingArea, blockHash *externalapi.DomainHash, isTrustedData bool) (*externalapi.BlockGHOSTDAGData, error)
+	UnstageAll(stagingArea *StagingArea)
 }

domain/consensus/model/interface_datastructures_reachabilitydatastore.go

@@ -11,4 +11,5 @@ type ReachabilityDataStore interface {
 	ReachabilityData(dbContext DBReader, stagingArea *StagingArea, blockHash *externalapi.DomainHash) (ReachabilityData, error)
 	HasReachabilityData(dbContext DBReader, stagingArea *StagingArea, blockHash *externalapi.DomainHash) (bool, error)
 	ReachabilityReindexRoot(dbContext DBReader, stagingArea *StagingArea) (*externalapi.DomainHash, error)
+	Delete(dbContext DBWriter) error
 }