Check checkpoint only if highestSharedBlockFound

.github/workflows/deploy.yaml

@@ -19,11 +19,16 @@ 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.18
+          go-version: 1.16
 
       - 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.18
+          go-version: 1.16
 
       - 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.18
+          go-version: 1.16
 
 
       # 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.18
+          go-version: 1.16
 
       - name: Checkout
         uses: actions/checkout@v2
@@ -86,7 +86,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v2
         with:
-          go-version: 1.18
+          go-version: 1.16
 
       - 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.18 or later.
+Go 1.16 or later.
 
 ## Installation
 

app/appmessage/message.go

@@ -69,10 +69,6 @@ const (
 	CmdReady
 	CmdTrustedData
 	CmdBlockWithTrustedDataV4
-	CmdRequestNextPruningPointAndItsAnticoneBlocks
-	CmdRequestIBDChainBlockLocator
-	CmdIBDChainBlockLocator
-	CmdRequestAnticone
 
 	// rpc
 	CmdGetCurrentNetworkRequestMessage
@@ -156,9 +152,6 @@ const (
 	CmdVirtualDaaScoreChangedNotificationMessage
 	CmdGetBalancesByAddressesRequestMessage
 	CmdGetBalancesByAddressesResponseMessage
-	CmdNotifyNewBlockTemplateRequestMessage
-	CmdNotifyNewBlockTemplateResponseMessage
-	CmdNewBlockTemplateNotificationMessage
 )
 
 // ProtocolMessageCommandToString maps all MessageCommands to their string representation
@@ -202,10 +195,6 @@ 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
@@ -289,9 +278,6 @@ 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

@@ -1,27 +0,0 @@
-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

@@ -1,33 +0,0 @@
-// 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

@@ -1,31 +0,0 @@
-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

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

app/appmessage/rpc_notify_new_block_template.go

@@ -1,50 +0,0 @@
-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,7 +153,6 @@ 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.Tracef("OnNewBlock start for block %s", hash)
-	defer log.Tracef("OnNewBlock end for block %s", hash)
+	log.Debugf("OnNewBlock start for block %s", hash)
+	defer log.Debugf("OnNewBlock end for block %s", hash)
 
 	unorphaningResults, err := f.UnorphanBlocks(block)
 	if err != nil {
@@ -68,15 +68,6 @@ 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 {
@@ -134,10 +125,6 @@ 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
@@ -163,7 +150,7 @@ func (f *FlowContext) TrySetIBDRunning(ibdPeer *peerpkg.Peer) bool {
 		return false
 	}
 	f.ibdPeer = ibdPeer
-	log.Infof("IBD started with peer %s", ibdPeer)
+	log.Infof("IBD started")
 
 	return true
 }

app/protocol/flowcontext/errors.go

@@ -2,7 +2,6 @@ package flowcontext
 
 import (
 	"errors"
-	"strings"
 	"sync/atomic"
 
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
@@ -10,11 +9,6 @@ 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
 //
@@ -27,15 +21,8 @@ func (*FlowContext) HandleError(err error, flowName string, isStopping *uint32,
 		if protocolErr := (protocolerrors.ProtocolError{}); !errors.As(err, &protocolErr) {
 			panic(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)
-		}
+
+		log.Errorf("error from %s: %s", flowName, err)
 	}
 
 	if atomic.AddUint32(isStopping, 1) == 1 {

app/protocol/flowcontext/flow_context.go

@@ -25,9 +25,6 @@ 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
@@ -49,13 +46,11 @@ type FlowContext struct {
 
 	onVirtualChangeHandler               OnVirtualChangeHandler
 	onBlockAddedToDAGHandler             OnBlockAddedToDAGHandler
-	onNewBlockTemplateHandler            OnNewBlockTemplateHandler
 	onPruningPointUTXOSetOverrideHandler OnPruningPointUTXOSetOverrideHandler
 	onTransactionAddedToMempoolHandler   OnTransactionAddedToMempoolHandler
 
-	expectedDAAWindowDurationInMilliseconds int64
-	lastRebroadcastTime                     time.Time
-	sharedRequestedTransactions             *SharedRequestedTransactions
+	lastRebroadcastTime         time.Time
+	sharedRequestedTransactions *SharedRequestedTransactions
 
 	sharedRequestedBlocks *SharedRequestedBlocks
 
@@ -93,8 +88,6 @@ 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),
 	}
 }
 
@@ -119,11 +112,6 @@ 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,12 +2,21 @@ package flowcontext
 
 import "github.com/kaspanet/kaspad/util/mstime"
 
-// 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) {
+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) {
 	peers := f.Peers()
 	if len(peers) == 0 {
-		log.Debugf("The node is not connected to peers, so IsNearlySynced returns false")
+		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")
 		return false, nil
 	}
 
@@ -26,15 +35,13 @@ func (f *FlowContext) IsNearlySynced() (bool, error) {
 	}
 
 	now := mstime.Now().UnixMilliseconds()
-	// 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",
+	if now-virtualSelectedParentHeader.TimeInMilliseconds() < maxSelectedParentTimeDiffToAllowMiningInMilliSeconds {
+		log.Debugf("The selected tip timestamp is recent (%d), so ShouldMine returns true",
 			virtualSelectedParentHeader.TimeInMilliseconds())
 		return true, nil
 	}
 
-	log.Debugf("The selected tip timestamp is old (%d), so IsNearlySynced returns false",
+	log.Debugf("The selected tip timestamp is old (%d), so ShouldMine 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(5)
+	minAcceptableProtocolVersion = uint32(4)
 
-	maxAcceptableProtocolVersion = uint32(5)
+	maxAcceptableProtocolVersion = uint32(4)
 )
 
 type receiveVersionFlow struct {

app/protocol/flows/v4/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 (v5)", hash)
+				return protocolerrors.Errorf(true, "block %s not found", hash)
 			}
 			block, err := context.Domain().Consensus().GetBlock(hash)
 			if err != nil {

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

@@ -118,7 +118,7 @@ func HandlePruningPointAndItsAnticoneRequests(context PruningPointAndItsAnticone
 				return err
 			}
 
-			for i, blockHash := range pointAndItsAnticone {
+			for _, blockHash := range pointAndItsAnticone {
 				block, err := context.Domain().Consensus().GetBlock(blockHash)
 				if err != nil {
 					return err
@@ -128,19 +128,6 @@ 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/v4/blockrelay/handle_relay_invs.go

@@ -10,7 +10,6 @@ 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"
@@ -27,7 +26,6 @@ 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
@@ -36,7 +34,6 @@ type RelayInvsContext interface {
 	IsOrphan(blockHash *externalapi.DomainHash) bool
 	IsIBDRunning() bool
 	IsRecoverableError(err error) bool
-	IsNearlySynced() (bool, error)
 }
 
 type handleRelayInvsFlow struct {
@@ -107,16 +104,10 @@ func (flow *handleRelayInvsFlow) start() error {
 			continue
 		}
 
-		// Block relay is disabled if the node is already during IBD AND considered out of sync
+		// Block relay is disabled during IBD
 		if flow.IsIBDRunning() {
-			isNearlySynced, err := flow.IsNearlySynced()
-			if err != nil {
-				return err
-			}
-			if !isNearlySynced {
-				log.Debugf("Got block %s while in IBD and the node is out of sync. Continuing...", inv.Hash)
-				continue
-			}
+			log.Debugf("Got block %s while in IBD. continuing...", inv.Hash)
+			continue
 		}
 
 		log.Debugf("Requesting block %s", inv.Hash)
@@ -140,10 +131,6 @@ 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) {
@@ -166,42 +153,11 @@ func (flow *handleRelayInvsFlow) start() error {
 			continue
 		}
 
-		oldVirtualParents := hashset.New()
-		for _, parent := range oldVirtualInfo.ParentHashes {
-			oldVirtualParents.Add(parent)
-		}
-
-		newVirtualInfo, err := flow.Domain().Consensus().GetVirtualInfo()
+		log.Debugf("Relaying block %s", inv.Hash)
+		err = flow.relayBlock(block)
 		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 {
@@ -302,10 +258,7 @@ func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([
 		if errors.As(err, missingParentsError) {
 			return missingParentsError.MissingParentHashes, nil, nil
 		}
-		// A duplicate block should not appear to the user as a warning and is already reported in the calling function
-		if !errors.Is(err, ruleerrors.ErrDuplicateBlock) {
-			log.Warnf("Rejected block %s from %s: %s", blockHash, flow.peer, err)
-		}
+		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
@@ -416,10 +369,6 @@ 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/v4/blockrelay/handle_request_headers.go

@@ -10,9 +10,7 @@ import (
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
-// This constant must be equal at both syncer and syncee. Therefore, never (!!) change this constant unless a new p2p
-// version is introduced. See `TestIBDBatchSizeLessThanRouteCapacity` as well.
-const ibdBatchSize = 99
+const ibdBatchSize = router.DefaultMaxMessages
 
 // RequestHeadersContext is the interface for the context needed for the HandleRequestHeaders flow.
 type RequestHeadersContext interface {
@@ -44,16 +42,7 @@ func (flow *handleRequestHeadersFlow) start() error {
 		if err != nil {
 			return err
 		}
-		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)
-		}
+		log.Debugf("Recieved requestHeaders with lowHash: %s, highHash: %s", lowHash, highHash)
 
 		for !lowHash.Equal(highHash) {
 			log.Debugf("Getting block headers between %s and %s to %s", lowHash, highHash, flow.peer)

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

@@ -6,6 +6,7 @@ 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"
@@ -22,7 +23,6 @@ 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
@@ -76,19 +76,40 @@ func (flow *handleIBDFlow) runIBDIfNotRunning(block *externalapi.DomainBlock) er
 		flow.logIBDFinished(isFinishedSuccessfully)
 	}()
 
-	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()
+	highHash := consensushashing.BlockHash(block)
+	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)
 	if err != nil {
 		return err
 	}
+	log.Criticalf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
+	if highestSharedBlockFound {
+		checkpoint, err := externalapi.NewDomainHashFromString("05ff0f2e1d201dcaee7c5e567cc2c1d42ca3cce9fefbd3b519dc68b5bb89d0b9")
+		if err != nil {
+			return err
+		}
 
-	shouldDownloadHeadersProof, shouldSync, err := flow.shouldSyncAndShouldDownloadHeadersProof(
-		block, highestKnownSyncerChainHash)
+		info, err := flow.Domain().Consensus().GetBlockInfo(checkpoint)
+		if err != nil {
+			return err
+		}
+
+		if info.Exists {
+			isInSelectedParentChainOf, err := flow.Domain().Consensus().IsInSelectedParentChainOf(checkpoint, highestSharedBlockHash)
+			if err != nil {
+				return err
+			}
+
+			if !isInSelectedParentChainOf {
+				log.Criticalf("Stopped IBD because the checkpoint %s is not in the selected chain of %s", checkpoint, highestSharedBlockHash)
+				return nil
+			}
+		}
+	}
+
+	shouldDownloadHeadersProof, shouldSync, err := flow.shouldSyncAndShouldDownloadHeadersProof(block, highestSharedBlockFound)
 	if err != nil {
 		return err
 	}
@@ -99,7 +120,7 @@ func (flow *handleIBDFlow) runIBDIfNotRunning(block *externalapi.DomainBlock) er
 
 	if shouldDownloadHeadersProof {
 		log.Infof("Starting IBD with headers proof")
-		err := flow.ibdWithHeadersProof(syncerHeaderSelectedTipHash, relayBlockHash, block.Header.DAAScore())
+		err := flow.ibdWithHeadersProof(highHash, block.Header.DAAScore())
 		if err != nil {
 			return err
 		}
@@ -112,162 +133,27 @@ 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.", relayBlockHash)
+					"to the recent pruning point before normal operation can resume.", highHash)
 				return nil
 			}
 		}
 
-		err = flow.syncPruningPointFutureHeaders(
-			flow.Domain().Consensus(),
-			syncerHeaderSelectedTipHash, highestKnownSyncerChainHash, relayBlockHash, block.Header.DAAScore())
+		err = flow.syncPruningPointFutureHeaders(flow.Domain().Consensus(), highestSharedBlockHash, highHash, block.Header.DAAScore())
 		if err != nil {
 			return err
 		}
 	}
 
-	// We start by syncing missing bodies over the syncer selected chain
-	err = flow.syncMissingBlockBodies(syncerHeaderSelectedTipHash)
+	err = flow.syncMissingBlockBodies(highHash)
 	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", relayBlockHash)
+	log.Debugf("Finished syncing blocks up to %s", highHash)
 	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 {
@@ -282,57 +168,141 @@ func (flow *handleIBDFlow) logIBDFinished(isFinishedSuccessfully bool) {
 	if !isFinishedSuccessfully {
 		successString = "(interrupted)"
 	}
-	log.Infof("IBD with peer %s finished %s", flow.peer, successString)
+	log.Infof("IBD finished %s", successString)
 }
 
-func (flow *handleIBDFlow) getSyncerChainBlockLocator(
-	highHash, lowHash *externalapi.DomainHash, timeout time.Duration) ([]*externalapi.DomainHash, error) {
+// 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) {
 
-	requestIbdChainBlockLocatorMessage := appmessage.NewMsgIBDRequestChainBlockLocator(highHash, lowHash)
-	err := flow.outgoingRoute.Enqueue(requestIbdChainBlockLocatorMessage)
+	log.Debugf("Sending a blockLocator to %s between pruning point and headers selected tip", flow.peer)
+	blockLocator, err := flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
-	message, err := flow.incomingRoute.DequeueWithTimeout(timeout)
+
+	for {
+		highestHash, highestHashFound, err := flow.fetchHighestHash(targetHash, blockLocator)
+		if err != nil {
+			return nil, false, err
+		}
+		if !highestHashFound {
+			return nil, false, nil
+		}
+		highestHashIndex, err := flow.findHighestHashIndex(highestHash, blockLocator)
+		if err != nil {
+			return nil, false, err
+		}
+
+		if highestHashIndex == 0 ||
+			// If the block locator contains only two adjacent chain blocks, the
+			// syncer will always find the same highest chain block, so to avoid
+			// an endless loop, we explicitly stop the loop in such situation.
+			(len(blockLocator) == 2 && highestHashIndex == 1) {
+
+			return highestHash, true, nil
+		}
+
+		locatorHashAboveHighestHash := highestHash
+		if highestHashIndex > 0 {
+			locatorHashAboveHighestHash = blockLocator[highestHashIndex-1]
+		}
+
+		blockLocator, err = flow.nextBlockLocator(highestHash, locatorHashAboveHighestHash)
+		if err != nil {
+			return nil, false, err
+		}
+	}
+}
+
+func (flow *handleIBDFlow) nextBlockLocator(lowHash, highHash *externalapi.DomainHash) (externalapi.BlockLocator, error) {
+	log.Debugf("Sending a blockLocator to %s between %s and %s", flow.peer, lowHash, highHash)
+	blockLocator, err := flow.Domain().Consensus().CreateHeadersSelectedChainBlockLocator(lowHash, highHash)
 	if err != nil {
-		return nil, err
+		if errors.Is(model.ErrBlockNotInSelectedParentChain, err) {
+			return nil, err
+		}
+		log.Debugf("Headers selected parent chain moved since findHighestSharedBlockHash - " +
+			"restarting with full block locator")
+		blockLocator, err = flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return blockLocator, nil
+}
+
+func (flow *handleIBDFlow) findHighestHashIndex(
+	highestHash *externalapi.DomainHash, blockLocator externalapi.BlockLocator) (int, error) {
+
+	highestHashIndex := 0
+	highestHashIndexFound := false
+	for i, blockLocatorHash := range blockLocator {
+		if highestHash.Equal(blockLocatorHash) {
+			highestHashIndex = i
+			highestHashIndexFound = true
+			break
+		}
+	}
+	if !highestHashIndexFound {
+		return 0, protocolerrors.Errorf(true, "highest hash %s "+
+			"returned from peer %s is not in the original blockLocator", highestHash, flow.peer)
+	}
+	log.Debugf("The index of the highest hash in the original "+
+		"blockLocator sent to %s is %d", flow.peer, highestHashIndex)
+
+	return highestHashIndex, nil
+}
+
+// fetchHighestHash attempts to fetch the highest hash the peer knows amongst the given
+// blockLocator. This method may fail because the peer and us have conflicting pruning
+// points. In that case we return (nil, false, nil) so that we may stop IBD gracefully.
+func (flow *handleIBDFlow) fetchHighestHash(
+	targetHash *externalapi.DomainHash, blockLocator externalapi.BlockLocator) (*externalapi.DomainHash, bool, error) {
+
+	ibdBlockLocatorMessage := appmessage.NewMsgIBDBlockLocator(targetHash, blockLocator)
+	err := flow.outgoingRoute.Enqueue(ibdBlockLocatorMessage)
+	if err != nil {
+		return nil, false, err
+	}
+	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+	if err != nil {
+		return nil, false, err
 	}
 	switch message := message.(type) {
-	case *appmessage.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
+	case *appmessage.MsgIBDBlockLocatorHighestHash:
+		highestHash := message.HighestHash
+		log.Debugf("The highest hash the peer %s knows is %s", flow.peer, highestHash)
+
+		return highestHash, true, nil
+	case *appmessage.MsgIBDBlockLocatorHighestHashNotFound:
+		log.Debugf("Peer %s does not know any block within our blockLocator. "+
+			"This should only happen if there's a DAG split deeper than the pruning point.", flow.peer)
+		return nil, false, nil
 	default:
-		return nil, protocolerrors.Errorf(true, "received unexpected message type. "+
-			"expected: %s, got: %s", appmessage.CmdIBDChainBlockLocator, message.Command())
+		return nil, false, protocolerrors.Errorf(true, "received unexpected message type. "+
+			"expected: %s, got: %s", appmessage.CmdIBDBlockLocatorHighestHash, message.Command())
 	}
 }
 
-func (flow *handleIBDFlow) syncPruningPointFutureHeaders(consensus externalapi.Consensus,
-	syncerHeaderSelectedTipHash, highestKnownSyncerChainHash, relayBlockHash *externalapi.DomainHash,
-	highBlockDAAScoreHint uint64) error {
+func (flow *handleIBDFlow) syncPruningPointFutureHeaders(consensus externalapi.Consensus, highestSharedBlockHash *externalapi.DomainHash,
+	highHash *externalapi.DomainHash, highBlockDAAScore uint64) error {
 
 	log.Infof("Downloading headers from %s", flow.peer)
 
-	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)
+	err := flow.sendRequestHeaders(highestSharedBlockHash, highHash)
 	if err != nil {
 		return err
 	}
 
-	highestSharedBlockHeader, err := consensus.GetBlockHeader(highestKnownSyncerChainHash)
+	highestSharedBlockHeader, err := consensus.GetBlockHeader(highestSharedBlockHash)
 	if err != nil {
 		return err
 	}
-	progressReporter := newIBDProgressReporter(highestSharedBlockHeader.DAAScore(), highBlockDAAScoreHint, "block headers")
+	progressReporter := newIBDProgressReporter(highestSharedBlockHeader.DAAScore(), highBlockDAAScore, "block headers")
 
 	// Keep a short queue of BlockHeadersMessages so that there's
 	// never a moment when the node is not validating and inserting
@@ -350,11 +320,6 @@ 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
 
@@ -370,10 +335,19 @@ func (flow *handleIBDFlow) syncPruningPointFutureHeaders(consensus externalapi.C
 		select {
 		case ibdBlocksMessage, ok := <-blockHeadersMessageChan:
 			if !ok {
-				return flow.syncMissingRelayPast(consensus, syncerHeaderSelectedTipHash, relayBlockHash)
+				// If the highHash has not been received, the peer is misbehaving
+				highHashBlockInfo, err := consensus.GetBlockInfo(highHash)
+				if err != nil {
+					return err
+				}
+				if !highHashBlockInfo.Exists {
+					return protocolerrors.Errorf(true, "did not receive "+
+						"highHash block %s from peer %s during block download", highHash, flow.peer)
+				}
+				return nil
 			}
 			for _, header := range ibdBlocksMessage.BlockHeaders {
-				err = flow.processHeader(consensus, header)
+				_, err := flow.processHeader(consensus, header)
 				if err != nil {
 					return err
 				}
@@ -387,70 +361,11 @@ func (flow *handleIBDFlow) syncPruningPointFutureHeaders(consensus externalapi.C
 	}
 }
 
-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
-			}
-		}
-	}
+func (flow *handleIBDFlow) sendRequestHeaders(highestSharedBlockHash *externalapi.DomainHash,
+	peerSelectedTipHash *externalapi.DomainHash) error {
 
-	// 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)
+	msgGetBlockInvs := appmessage.NewMsgRequstHeaders(highestSharedBlockHash, peerSelectedTipHash)
+	return flow.outgoingRoute.Enqueue(msgGetBlockInvs)
 }
 
 func (flow *handleIBDFlow) receiveHeaders() (msgIBDBlock *appmessage.BlockHeadersMessage, doneHeaders bool, err error) {
@@ -473,7 +388,7 @@ func (flow *handleIBDFlow) receiveHeaders() (msgIBDBlock *appmessage.BlockHeader
 	}
 }
 
-func (flow *handleIBDFlow) processHeader(consensus externalapi.Consensus, msgBlockHeader *appmessage.MsgBlockHeader) error {
+func (flow *handleIBDFlow) processHeader(consensus externalapi.Consensus, msgBlockHeader *appmessage.MsgBlockHeader) (bool, error) {
 	header := appmessage.BlockHeaderToDomainBlockHeader(msgBlockHeader)
 	block := &externalapi.DomainBlock{
 		Header:       header,
@@ -483,27 +398,26 @@ func (flow *handleIBDFlow) processHeader(consensus externalapi.Consensus, msgBlo
 	blockHash := consensushashing.BlockHash(block)
 	blockInfo, err := consensus.GetBlockInfo(blockHash)
 	if err != nil {
-		return err
+		return false, err
 	}
 	if blockInfo.Exists {
 		log.Debugf("Block header %s is already in the DAG. Skipping...", blockHash)
-		return nil
+		return false, nil
 	}
 	_, err = consensus.ValidateAndInsertBlock(block, false)
 	if err != nil {
 		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return errors.Wrapf(err, "failed to process header %s during IBD", blockHash)
+			return false, errors.Wrapf(err, "failed to process header %s during IBD", blockHash)
 		}
 
 		if errors.Is(err, ruleerrors.ErrDuplicateBlock) {
 			log.Debugf("Skipping block header %s as it is a duplicate", blockHash)
 		} else {
 			log.Infof("Rejected block header %s from %s during IBD: %s", blockHash, flow.peer, err)
-			return protocolerrors.Wrapf(true, err, "got invalid block header %s during IBD", blockHash)
+			return false, protocolerrors.Wrapf(true, err, "got invalid block header %s during IBD", blockHash)
 		}
 	}
-
-	return nil
+	return true, nil
 }
 
 func (flow *handleIBDFlow) validatePruningPointFutureHeaderTimestamps() error {
@@ -718,10 +632,6 @@ 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/v4/blockrelay/ibd_progress_reporter.go

@@ -10,10 +10,6 @@ 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,
@@ -27,16 +23,7 @@ func newIBDProgressReporter(lowDAAScore uint64, highDAAScore uint64, objectName
 func (ipr *ibdProgressReporter) reportProgress(processedDelta int, highestProcessedDAAScore uint64) {
 	ipr.processed += processedDelta
 
-	// Avoid exploding numbers in the percentage report, since the original `highDAAScore` might have been only a hint
-	if highestProcessedDAAScore > ipr.highDAAScore {
-		ipr.highDAAScore = highestProcessedDAAScore + 1 // + 1 for keeping it at 99%
-		ipr.totalDAAScoreDifference = ipr.highDAAScore - ipr.lowDAAScore
-	}
-	relativeDAAScore := uint64(0)
-	if highestProcessedDAAScore > ipr.lowDAAScore {
-		// Avoid a negative diff
-		relativeDAAScore = highestProcessedDAAScore - ipr.lowDAAScore
-	}
+	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/v4/blockrelay/ibd_with_headers_proof.go

@@ -12,20 +12,18 @@ import (
 	"time"
 )
 
-func (flow *handleIBDFlow) ibdWithHeadersProof(
-	syncerHeaderSelectedTipHash, relayBlockHash *externalapi.DomainHash, highBlockDAAScore uint64) error {
-	err := flow.Domain().InitStagingConsensusWithoutGenesis()
+func (flow *handleIBDFlow) ibdWithHeadersProof(highHash *externalapi.DomainHash, highBlockDAAScore uint64) error {
+	err := flow.Domain().InitStagingConsensus()
 	if err != nil {
 		return err
 	}
 
-	err = flow.downloadHeadersAndPruningUTXOSet(syncerHeaderSelectedTipHash, relayBlockHash, highBlockDAAScore)
+	err = flow.downloadHeadersAndPruningUTXOSet(highHash, highBlockDAAScore)
 	if err != nil {
 		if !flow.IsRecoverableError(err) {
 			return err
 		}
 
-		log.Infof("IBD with pruning proof from %s was unsuccessful. Deleting the staging consensus.", flow.peer)
 		deleteStagingConsensusErr := flow.Domain().DeleteStagingConsensus()
 		if deleteStagingConsensusErr != nil {
 			return deleteStagingConsensusErr
@@ -34,8 +32,6 @@ func (flow *handleIBDFlow) ibdWithHeadersProof(
 		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
@@ -49,29 +45,11 @@ func (flow *handleIBDFlow) ibdWithHeadersProof(
 	return nil
 }
 
-func (flow *handleIBDFlow) shouldSyncAndShouldDownloadHeadersProof(
-	relayBlock *externalapi.DomainBlock,
-	highestKnownSyncerChainHash *externalapi.DomainHash) (shouldDownload, shouldSync bool, err error) {
+func (flow *handleIBDFlow) shouldSyncAndShouldDownloadHeadersProof(highBlock *externalapi.DomainBlock,
+	highestSharedBlockFound bool) (shouldDownload, shouldSync bool, err error) {
 
-	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 !highestSharedBlockFound {
+		hasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore, err := flow.checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore(highBlock)
 		if err != nil {
 			return false, false, err
 		}
@@ -86,7 +64,7 @@ func (flow *handleIBDFlow) shouldSyncAndShouldDownloadHeadersProof(
 	return false, true, nil
 }
 
-func (flow *handleIBDFlow) checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore(relayBlock *externalapi.DomainBlock) (bool, error) {
+func (flow *handleIBDFlow) checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore(highBlock *externalapi.DomainBlock) (bool, error) {
 	headersSelectedTip, err := flow.Domain().Consensus().GetHeadersSelectedTip()
 	if err != nil {
 		return false, err
@@ -97,11 +75,11 @@ func (flow *handleIBDFlow) checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruni
 		return false, err
 	}
 
-	if relayBlock.Header.BlueScore() < headersSelectedTipInfo.BlueScore+flow.Config().NetParams().PruningDepth() {
+	if highBlock.Header.BlueScore() < headersSelectedTipInfo.BlueScore+flow.Config().NetParams().PruningDepth() {
 		return false, nil
 	}
 
-	return relayBlock.Header.BlueWork().Cmp(headersSelectedTipInfo.BlueWork) > 0, nil
+	return highBlock.Header.BlueWork().Cmp(headersSelectedTipInfo.BlueWork) > 0, nil
 }
 
 func (flow *handleIBDFlow) syncAndValidatePruningPointProof() (*externalapi.DomainHash, error) {
@@ -136,10 +114,7 @@ func (flow *handleIBDFlow) syncAndValidatePruningPointProof() (*externalapi.Doma
 	return consensushashing.HeaderHash(pruningPointProof.Headers[0][len(pruningPointProof.Headers[0])-1]), nil
 }
 
-func (flow *handleIBDFlow) downloadHeadersAndPruningUTXOSet(
-	syncerHeaderSelectedTipHash, relayBlockHash *externalapi.DomainHash,
-	highBlockDAAScore uint64) error {
-
+func (flow *handleIBDFlow) downloadHeadersAndPruningUTXOSet(highHash *externalapi.DomainHash, highBlockDAAScore uint64) error {
 	proofPruningPoint, err := flow.syncAndValidatePruningPointProof()
 	if err != nil {
 		return err
@@ -156,20 +131,19 @@ func (flow *handleIBDFlow) downloadHeadersAndPruningUTXOSet(
 		return protocolerrors.Errorf(true, "the genesis pruning point violates finality")
 	}
 
-	err = flow.syncPruningPointFutureHeaders(flow.Domain().StagingConsensus(),
-		syncerHeaderSelectedTipHash, proofPruningPoint, relayBlockHash, highBlockDAAScore)
+	err = flow.syncPruningPointFutureHeaders(flow.Domain().StagingConsensus(), proofPruningPoint, highHash, highBlockDAAScore)
 	if err != nil {
 		return err
 	}
 
 	log.Infof("Headers downloaded from peer %s", flow.peer)
 
-	relayBlockInfo, err := flow.Domain().StagingConsensus().GetBlockInfo(relayBlockHash)
+	highHashInfo, err := flow.Domain().StagingConsensus().GetBlockInfo(highHash)
 	if err != nil {
 		return err
 	}
 
-	if !relayBlockInfo.Exists {
+	if !highHashInfo.Exists {
 		return protocolerrors.Errorf(true, "the triggering IBD block was not sent")
 	}
 
@@ -232,8 +206,7 @@ func (flow *handleIBDFlow) syncPruningPointsAndPruningPointAnticone(proofPruning
 		return err
 	}
 
-	i := 0
-	for ; ; i++ {
+	for {
 		blockWithTrustedData, done, err := flow.receiveBlockWithTrustedData()
 		if err != nil {
 			return err
@@ -247,19 +220,9 @@ 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. Total blocks downloaded: %d", flow.peer, i+1)
+	log.Infof("Finished downloading pruning point and its anticone from %s", flow.peer)
 	return nil
 }
 
@@ -381,7 +344,6 @@ 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/v4/ping/send.go

@@ -2,8 +2,6 @@ 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"
@@ -63,9 +61,6 @@ 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/v4/register.go

@@ -1,14 +1,14 @@
-package v5
+package v4
 
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	"github.com/kaspanet/kaspad/app/protocol/flowcontext"
-	"github.com/kaspanet/kaspad/app/protocol/flows/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"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v4/addressexchange"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v4/blockrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v4/ping"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v4/rejects"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v4/transactionrelay"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	routerpkg "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
@@ -78,7 +78,6 @@ 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,
@@ -122,7 +121,7 @@ func registerBlockRelayFlows(m protocolManager, router *routerpkg.Router, isStop
 		),
 
 		m.RegisterFlow("HandlePruningPointAndItsAnticoneRequests", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointAndItsAnticone, appmessage.CmdRequestNextPruningPointAndItsAnticoneBlocks}, isStopping, errChan,
+			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointAndItsAnticone}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
 				return blockrelay.HandlePruningPointAndItsAnticoneRequests(m.Context(), incomingRoute, outgoingRoute, peer)
 			},
@@ -135,20 +134,6 @@ 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/v4/testing/receiveaddresses_test.go

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

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

@@ -22,7 +22,7 @@ type TransactionsRelayContext interface {
 	SharedRequestedTransactions() *flowcontext.SharedRequestedTransactions
 	OnTransactionAddedToMempool()
 	EnqueueTransactionIDsForPropagation(transactionIDs []*externalapi.DomainTransactionID) error
-	IsNearlySynced() (bool, error)
+	IsIBDRunning() bool
 }
 
 type handleRelayedTransactionsFlow struct {
@@ -50,12 +50,7 @@ func (flow *handleRelayedTransactionsFlow) start() error {
 			return err
 		}
 
-		isNearlySynced, err := flow.IsNearlySynced()
-		if err != nil {
-			return err
-		}
-		// Transaction relay is disabled if the node is out of sync and thus not mining
-		if !isNearlySynced {
+		if flow.IsIBDRunning() {
 			continue
 		}
 

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

app/protocol/flows/v4/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/v5/transactionrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/v4/transactionrelay"
 	"testing"
 
 	"github.com/kaspanet/kaspad/app/appmessage"

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

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

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

@@ -1,85 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model"
-	"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_request_anticone.go

@@ -1,95 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/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/manager.go

@@ -100,11 +100,6 @@ 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)
@@ -118,7 +113,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.IsNearlySynced()
+	return m.context.ShouldMine()
 }
 
 // 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"
-	"github.com/kaspanet/kaspad/app/protocol/flows/v5"
+	v4 "github.com/kaspanet/kaspad/app/protocol/flows/v4"
 	"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 5:
-			flows = v5.Register(m, router, errChan, &isStopping)
+		case 4:
+			flows = v4.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.NotifyVirtualChange")
+	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyBlockAddedToDAG")
 	defer onEnd()
 
 	if m.context.Config.UTXOIndex {
@@ -96,13 +96,6 @@ 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,7 +48,6 @@ 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,7 +32,6 @@ type NotificationListener struct {
 	propagateVirtualSelectedParentBlueScoreChangedNotifications bool
 	propagateVirtualDaaScoreChangedNotifications                bool
 	propagatePruningPointUTXOSetOverrideNotifications           bool
-	propagateNewBlockTemplateNotifications                      bool
 
 	propagateUTXOsChangedNotificationAddresses map[utxoindex.ScriptPublicKeyString]*UTXOsChangedNotificationAddress
 }
@@ -202,25 +201,6 @@ 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 {
@@ -246,7 +226,6 @@ func newNotificationListener() *NotificationListener {
 		propagateFinalityConflictResolvedNotifications:              false,
 		propagateUTXOsChangedNotifications:                          false,
 		propagateVirtualSelectedParentBlueScoreChangedNotifications: false,
-		propagateNewBlockTemplateNotifications:                      false,
 		propagatePruningPointUTXOSetOverrideNotifications:           false,
 	}
 }
@@ -355,12 +334,6 @@ 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,11 +4,9 @@ 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
@@ -17,7 +15,7 @@ func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, reque
 
 	payAddress, err := util.DecodeAddress(getBlockTemplateRequest.PayAddress, context.Config.ActiveNetParams.Prefix)
 	if err != nil {
-		errorMessage := &appmessage.GetBlockTemplateResponseMessage{}
+		errorMessage := &appmessage.GetBlockResponseMessage{}
 		errorMessage.Error = appmessage.RPCErrorf("Could not decode address: %s", err)
 		return errorMessage, nil
 	}
@@ -27,18 +25,12 @@ func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, reque
 		return nil, err
 	}
 
-	coinbaseData := &externalapi.DomainCoinbaseData{ScriptPublicKey: scriptPublicKey, ExtraData: []byte(version.Version() + "/" + getBlockTemplateRequest.ExtraData)}
+	coinbaseData := &externalapi.DomainCoinbaseData{ScriptPublicKey: scriptPublicKey}
+
 	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) InitStagingConsensusWithoutGenesis() error {
+func (d fakeDomain) InitStagingConsensus() error {
 	panic("implement me")
 }
 

app/rpc/rpchandlers/notify_new_block_template.go

@@ -1,19 +0,0 @@
-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,7 +1,6 @@
 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"
@@ -59,12 +58,6 @@ 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,8 +5,9 @@ FLAGS=$@
 go version
 
 go get $FLAGS -t -d ./...
-GO111MODULE=off go get $FLAGS golang.org/x/lint/golint
-go install $FLAGS honnef.co/go/tools/cmd/staticcheck@latest
+# 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
 
 test -z "$(go fmt ./...)"
 

changelog.txt

@@ -1,53 +1,3 @@
-Kaspad v0.11.16 - 2022-04-05
-===========================
-* Don't skip wallet address with different cosigner index (#2007)
-
-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.18 or later.
+Go 1.16 or later.
 
 ## Installation
 

cmd/kaspactl/docker/Dockerfile

@@ -1,5 +1,5 @@
 # -- multistage docker build: stage #1: build stage
-FROM golang:1.18-alpine AS build
+FROM golang:1.16-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.18 or later.
+Go 1.16 or later.
 
 ## Installation
 

cmd/kaspaminer/client.go

@@ -13,8 +13,8 @@ const minerTimeout = 10 * time.Second
 type minerClient struct {
 	*rpcclient.RPCClient
 
-	cfg                              *configFlags
-	newBlockTemplateNotificationChan chan struct{}
+	cfg                        *configFlags
+	blockAddedNotificationChan 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.RegisterForNewBlockTemplateNotifications(func(_ *appmessage.NewBlockTemplateNotificationMessage) {
+	err = mc.RegisterForBlockAddedNotifications(func(_ *appmessage.BlockAddedNotificationMessage) {
 		select {
-		case mc.newBlockTemplateNotificationChan <- struct{}{}:
+		case mc.blockAddedNotificationChan <- struct{}{}:
 		default:
 		}
 	})
 	if err != nil {
-		return errors.Wrapf(err, "error requesting new-block-template notifications")
+		return errors.Wrapf(err, "error requesting block-added 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,
-		newBlockTemplateNotificationChan: make(chan struct{}),
+		cfg:                        cfg,
+		blockAddedNotificationChan: make(chan struct{}),
 	}
 
 	err := minerClient.connect()

cmd/kaspaminer/docker/Dockerfile

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

cmd/kaspaminer/mineloop.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	nativeerrors "errors"
-	"github.com/kaspanet/kaspad/version"
 	"math/rand"
 	"sync/atomic"
 	"time"
@@ -188,7 +187,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(), "kaspaminer-"+version.Version())
+		template, err := client.GetBlockTemplate(miningAddr.String())
 		if nativeerrors.Is(err, router.ErrTimeout) {
 			log.Warnf("Got timeout while requesting block template from %s: %s", client.Address(), err)
 			reconnectErr := client.Reconnect()
@@ -218,7 +217,7 @@ func templatesLoop(client *minerClient, miningAddr util.Address, errChan chan er
 	ticker := time.NewTicker(tickerTime)
 	for {
 		select {
-		case <-client.newBlockTemplateNotificationChan:
+		case <-client.blockAddedNotificationChan:
 			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,40 +21,34 @@ func broadcast(conf *broadcastConfig) error {
 	ctx, cancel := context.WithTimeout(context.Background(), daemonTimeout)
 	defer cancel()
 
-	if conf.Transactions == "" && conf.TransactionsFile == "" {
+	if conf.Transaction == "" && conf.TransactionFile == "" {
 		return errors.Errorf("Either --transaction or --transaction-file is required")
 	}
-	if conf.Transactions != "" && conf.TransactionsFile != "" {
+	if conf.Transaction != "" && conf.TransactionFile != "" {
 		return errors.Errorf("Both --transaction and --transaction-file cannot be passed at the same time")
 	}
 
-	transactionsHex := conf.Transactions
-	if conf.TransactionsFile != "" {
-		transactionHexBytes, err := ioutil.ReadFile(conf.TransactionsFile)
+	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.TransactionsFile)
+			return errors.Wrapf(err, "Could not read hex from %s", conf.TransactionFile)
 		}
-		transactionsHex = strings.TrimSpace(string(transactionHexBytes))
+		transactionHex = strings.TrimSpace(string(transactionHexBytes))
 	}
 
-	transactions, err := decodeTransactionsFromHex(transactionsHex)
+	transaction, err := hex.DecodeString(transactionHex)
 	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)
+	response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{Transaction: transaction})
+	if err != nil {
+		return err
 	}
 
+	fmt.Println("Transaction was sent successfully")
+	fmt.Printf("Transaction ID: \t%s\n", response.TxID)
+
 	return nil
 }

cmd/kaspawallet/config.go

@@ -1,10 +1,9 @@
 package main
 
 import (
-	"os"
-
 	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/pkg/errors"
+	"os"
 
 	"github.com/jessevdk/go-flags"
 )
@@ -69,15 +68,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(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)"`
+	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)"`
 	config.NetworkFlags
 }
 
 type broadcastConfig struct {
-	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)"`
+	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)"`
 	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.CreateUnsignedTransactions(ctx, &pb.CreateUnsignedTransactionsRequest{
+	response, err := daemonClient.CreateUnsignedTransaction(ctx, &pb.CreateUnsignedTransactionRequest{
 		Address: conf.ToAddress,
 		Amount:  sendAmountSompi,
 	})
@@ -29,6 +29,6 @@ func createUnsignedTransaction(conf *createUnsignedTransactionConfig) error {
 	}
 
 	fmt.Println("Created unsigned transaction")
-	fmt.Println(encodeTransactionsToHex(response.UnsignedTransactions))
+	fmt.Println(hex.EncodeToString(response.UnsignedTransaction))
 	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.26.0
-// 	protoc        v3.19.4
+// 	protoc-gen-go v1.27.1
+// 	protoc        v3.12.3
 // source: kaspawalletd.proto
 
 package pb
@@ -184,7 +184,7 @@ func (x *AddressBalances) GetPending() uint64 {
 	return 0
 }
 
-type CreateUnsignedTransactionsRequest struct {
+type CreateUnsignedTransactionRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
@@ -193,8 +193,8 @@ type CreateUnsignedTransactionsRequest struct {
 	Amount  uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
 }
 
-func (x *CreateUnsignedTransactionsRequest) Reset() {
-	*x = CreateUnsignedTransactionsRequest{}
+func (x *CreateUnsignedTransactionRequest) Reset() {
+	*x = CreateUnsignedTransactionRequest{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_kaspawalletd_proto_msgTypes[3]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -202,13 +202,13 @@ func (x *CreateUnsignedTransactionsRequest) Reset() {
 	}
 }
 
-func (x *CreateUnsignedTransactionsRequest) String() string {
+func (x *CreateUnsignedTransactionRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*CreateUnsignedTransactionsRequest) ProtoMessage() {}
+func (*CreateUnsignedTransactionRequest) ProtoMessage() {}
 
-func (x *CreateUnsignedTransactionsRequest) ProtoReflect() protoreflect.Message {
+func (x *CreateUnsignedTransactionRequest) 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 *CreateUnsignedTransactionsRequest) ProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use CreateUnsignedTransactionsRequest.ProtoReflect.Descriptor instead.
-func (*CreateUnsignedTransactionsRequest) Descriptor() ([]byte, []int) {
+// Deprecated: Use CreateUnsignedTransactionRequest.ProtoReflect.Descriptor instead.
+func (*CreateUnsignedTransactionRequest) Descriptor() ([]byte, []int) {
 	return file_kaspawalletd_proto_rawDescGZIP(), []int{3}
 }
 
-func (x *CreateUnsignedTransactionsRequest) GetAddress() string {
+func (x *CreateUnsignedTransactionRequest) GetAddress() string {
 	if x != nil {
 		return x.Address
 	}
 	return ""
 }
 
-func (x *CreateUnsignedTransactionsRequest) GetAmount() uint64 {
+func (x *CreateUnsignedTransactionRequest) GetAmount() uint64 {
 	if x != nil {
 		return x.Amount
 	}
 	return 0
 }
 
-type CreateUnsignedTransactionsResponse struct {
+type CreateUnsignedTransactionResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	UnsignedTransactions [][]byte `protobuf:"bytes,1,rep,name=unsignedTransactions,proto3" json:"unsignedTransactions,omitempty"`
+	UnsignedTransaction []byte `protobuf:"bytes,1,opt,name=unsignedTransaction,proto3" json:"unsignedTransaction,omitempty"`
 }
 
-func (x *CreateUnsignedTransactionsResponse) Reset() {
-	*x = CreateUnsignedTransactionsResponse{}
+func (x *CreateUnsignedTransactionResponse) Reset() {
+	*x = CreateUnsignedTransactionResponse{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_kaspawalletd_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -256,13 +256,13 @@ func (x *CreateUnsignedTransactionsResponse) Reset() {
 	}
 }
 
-func (x *CreateUnsignedTransactionsResponse) String() string {
+func (x *CreateUnsignedTransactionResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*CreateUnsignedTransactionsResponse) ProtoMessage() {}
+func (*CreateUnsignedTransactionResponse) ProtoMessage() {}
 
-func (x *CreateUnsignedTransactionsResponse) ProtoReflect() protoreflect.Message {
+func (x *CreateUnsignedTransactionResponse) 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 *CreateUnsignedTransactionsResponse) ProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use CreateUnsignedTransactionsResponse.ProtoReflect.Descriptor instead.
-func (*CreateUnsignedTransactionsResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use CreateUnsignedTransactionResponse.ProtoReflect.Descriptor instead.
+func (*CreateUnsignedTransactionResponse) Descriptor() ([]byte, []int) {
 	return file_kaspawalletd_proto_rawDescGZIP(), []int{4}
 }
 
-func (x *CreateUnsignedTransactionsResponse) GetUnsignedTransactions() [][]byte {
+func (x *CreateUnsignedTransactionResponse) GetUnsignedTransaction() []byte {
 	if x != nil {
-		return x.UnsignedTransactions
+		return x.UnsignedTransaction
 	}
 	return nil
 }
@@ -630,92 +630,80 @@ 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, 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,
+	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,
 }
 
 var (
@@ -732,34 +720,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: 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
+	(*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
 }
 var file_kaspawalletd_proto_depIdxs = []int32{
-	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
+	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
 	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
@@ -810,7 +798,7 @@ func file_kaspawalletd_proto_init() {
 			}
 		}
 		file_kaspawalletd_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*CreateUnsignedTransactionsRequest); i {
+			switch v := v.(*CreateUnsignedTransactionRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -822,7 +810,7 @@ func file_kaspawalletd_proto_init() {
 			}
 		}
 		file_kaspawalletd_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*CreateUnsignedTransactionsResponse); i {
+			switch v := v.(*CreateUnsignedTransactionResponse); i {
 			case 0:
 				return &v.state
 			case 1:

cmd/kaspawallet/daemon/pb/kaspawalletd.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 option go_package = "github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb";
-package kaspawalletd;
 
 service kaspawalletd {
   rpc GetBalance (GetBalanceRequest) returns (GetBalanceResponse) {}
-  rpc CreateUnsignedTransactions (CreateUnsignedTransactionsRequest) returns (CreateUnsignedTransactionsResponse) {}
+  rpc CreateUnsignedTransaction (CreateUnsignedTransactionRequest) returns (CreateUnsignedTransactionResponse) {}
   rpc ShowAddresses (ShowAddressesRequest) returns (ShowAddressesResponse) {}
   rpc NewAddress (NewAddressRequest) returns (NewAddressResponse) {}
   rpc Shutdown (ShutdownRequest) returns (ShutdownResponse) {}
@@ -27,13 +26,13 @@ message AddressBalances {
     uint64 pending = 3;
 }
 
-message CreateUnsignedTransactionsRequest {
+message CreateUnsignedTransactionRequest {
   string address = 1;
   uint64 amount = 2;
 }
 
-message CreateUnsignedTransactionsResponse {
-  repeated bytes unsignedTransactions = 1;
+message CreateUnsignedTransactionResponse {
+  bytes unsignedTransaction = 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)
-	CreateUnsignedTransactions(ctx context.Context, in *CreateUnsignedTransactionsRequest, opts ...grpc.CallOption) (*CreateUnsignedTransactionsResponse, error)
+	CreateUnsignedTransaction(ctx context.Context, in *CreateUnsignedTransactionRequest, opts ...grpc.CallOption) (*CreateUnsignedTransactionResponse, 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.kaspawalletd/GetBalance", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/kaspawalletd/GetBalance", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-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...)
+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...)
 	if err != nil {
 		return nil, err
 	}
@@ -54,7 +54,7 @@ func (c *kaspawalletdClient) CreateUnsignedTransactions(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.kaspawalletd/ShowAddresses", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/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.kaspawalletd/NewAddress", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/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.kaspawalletd/Shutdown", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/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.kaspawalletd/Broadcast", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/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)
-	CreateUnsignedTransactions(context.Context, *CreateUnsignedTransactionsRequest) (*CreateUnsignedTransactionsResponse, error)
+	CreateUnsignedTransaction(context.Context, *CreateUnsignedTransactionRequest) (*CreateUnsignedTransactionResponse, 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) CreateUnsignedTransactions(context.Context, *CreateUnsignedTransactionsRequest) (*CreateUnsignedTransactionsResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CreateUnsignedTransactions not implemented")
+func (UnimplementedKaspawalletdServer) CreateUnsignedTransaction(context.Context, *CreateUnsignedTransactionRequest) (*CreateUnsignedTransactionResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreateUnsignedTransaction 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.kaspawalletd/GetBalance",
+		FullMethod: "/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_CreateUnsignedTransactions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(CreateUnsignedTransactionsRequest)
+func _Kaspawalletd_CreateUnsignedTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateUnsignedTransactionRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(KaspawalletdServer).CreateUnsignedTransactions(ctx, in)
+		return srv.(KaspawalletdServer).CreateUnsignedTransaction(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/kaspawalletd.kaspawalletd/CreateUnsignedTransactions",
+		FullMethod: "/kaspawalletd/CreateUnsignedTransaction",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(KaspawalletdServer).CreateUnsignedTransactions(ctx, req.(*CreateUnsignedTransactionsRequest))
+		return srv.(KaspawalletdServer).CreateUnsignedTransaction(ctx, req.(*CreateUnsignedTransactionRequest))
 	}
 	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.kaspawalletd/ShowAddresses",
+		FullMethod: "/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.kaspawalletd/NewAddress",
+		FullMethod: "/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.kaspawalletd/Shutdown",
+		FullMethod: "/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.kaspawalletd/Broadcast",
+		FullMethod: "/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.kaspawalletd",
+	ServiceName: "kaspawalletd",
 	HandlerType: (*KaspawalletdServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
@@ -256,8 +256,8 @@ var Kaspawalletd_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _Kaspawalletd_GetBalance_Handler,
 		},
 		{
-			MethodName: "CreateUnsignedTransactions",
-			Handler:    _Kaspawalletd_CreateUnsignedTransactions_Handler,
+			MethodName: "CreateUnsignedTransaction",
+			Handler:    _Kaspawalletd_CreateUnsignedTransaction_Handler,
 		},
 		{
 			MethodName: "ShowAddresses",

cmd/kaspawallet/daemon/server/address.go

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

cmd/kaspawallet/daemon/server/create_unsigned_transaction.go

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

cmd/kaspawallet/daemon/server/server.go

@@ -7,8 +7,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/kaspanet/kaspad/util/txmass"
-
 	"github.com/kaspanet/kaspad/util/profiling"
 
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
@@ -34,7 +32,6 @@ type server struct {
 	keysFile            *keys.File
 	shutdown            chan struct{}
 	addressSet          walletAddressSet
-	txMassCalculator    *txmass.Calculator
 }
 
 // Start starts the kaspawalletd server
@@ -72,7 +69,6 @@ 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

@@ -1,278 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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/daemon/server/sync.go

@@ -159,6 +159,10 @@ func (s *server) updateAddressesAndLastUsedIndexes(requestedAddressSet walletAdd
 			continue
 		}
 
+		if walletAddress.cosignerIndex != s.keysFile.CosignerIndex {
+			continue
+		}
+
 		s.addressSet[entry.Address] = walletAddress
 
 		if walletAddress.keyChain == libkaspawallet.ExternalKeychain {

cmd/kaspawallet/libkaspawallet/serialization/serialization.go

@@ -34,44 +34,6 @@ 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,6 +40,7 @@ func Sign(params *dagconfig.Params, mnemonics []string, serializedPSTx []byte, e
 			return nil, err
 		}
 	}
+
 	return serialization.SerializePartiallySignedTransaction(partiallySignedTransaction)
 }
 

cmd/kaspawallet/libkaspawallet/transaction.go

@@ -159,7 +159,6 @@ func createUnsignedTransaction(
 		Tx:                    domainTransaction,
 		PartiallySignedInputs: partiallySignedInputs,
 	}, nil
-
 }
 
 // IsTransactionFullySigned returns whether the transaction is fully signed and ready to broadcast.
@@ -195,14 +194,10 @@ func ExtractTransaction(partiallySignedTransactionBytes []byte, ecdsa bool) (*ex
 		return nil, err
 	}
 
-	return ExtractTransactionDeserialized(partiallySignedTransaction, ecdsa)
+	return extractTransaction(partiallySignedTransaction, ecdsa)
 }
 
-// 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) {
-
+func extractTransaction(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,9 +2,6 @@ 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"
@@ -13,6 +10,8 @@ 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)) {
@@ -107,7 +106,7 @@ func TestMultisig(t *testing.T) {
 					Amount:  10,
 				}}, selectedUTXOs)
 			if err != nil {
-				t.Fatalf("CreateUnsignedTransactions: %+v", err)
+				t.Fatalf("CreateUnsignedTransaction: %+v", err)
 			}
 
 			isFullySigned, err := libkaspawallet.IsTransactionFullySigned(unsignedTransaction)
@@ -268,7 +267,7 @@ func TestP2PK(t *testing.T) {
 					Amount:  10,
 				}}, selectedUTXOs)
 			if err != nil {
-				t.Fatalf("CreateUnsignedTransactions: %+v", err)
+				t.Fatalf("CreateUnsignedTransaction: %+v", err)
 			}
 
 			isFullySigned, err := libkaspawallet.IsTransactionFullySigned(unsignedTransaction)

cmd/kaspawallet/send.go

@@ -3,7 +3,6 @@ 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"
@@ -32,11 +31,10 @@ func send(conf *sendConfig) error {
 	defer cancel()
 
 	sendAmountSompi := uint64(conf.SendAmount * constants.SompiPerKaspa)
-	createUnsignedTransactionsResponse, err :=
-		daemonClient.CreateUnsignedTransactions(ctx, &pb.CreateUnsignedTransactionsRequest{
-			Address: conf.ToAddress,
-			Amount:  sendAmountSompi,
-		})
+	createUnsignedTransactionResponse, err := daemonClient.CreateUnsignedTransaction(ctx, &pb.CreateUnsignedTransactionRequest{
+		Address: conf.ToAddress,
+		Amount:  sendAmountSompi,
+	})
 	if err != nil {
 		return err
 	}
@@ -46,37 +44,22 @@ func send(conf *sendConfig) error {
 		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
+	signedTransaction, err := libkaspawallet.Sign(conf.NetParams(), mnemonics, createUnsignedTransactionResponse.UnsignedTransaction, keysFile.ECDSA)
+	if err != nil {
+		return err
 	}
 
-	if len(signedTransactions) > 1 {
-		fmt.Printf("Broadcasting %d transactions\n", len(signedTransactions))
+	ctx2, cancel2 := context.WithTimeout(context.Background(), daemonTimeout)
+	defer cancel2()
+	broadcastResponse, err := daemonClient.Broadcast(ctx2, &pb.BroadcastRequest{
+		Transaction: signedTransaction,
+	})
+	if err != nil {
+		return err
 	}
-	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)
-			return nil
-		}()
-		if err != nil {
-			return err
-		}
-	}
+	fmt.Println("Transaction was sent successfully")
+	fmt.Printf("Transaction ID: \t%s\n", broadcastResponse.TxID)
 
 	return nil
 }

cmd/kaspawallet/sign.go

@@ -1,16 +1,21 @@
 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")
 	}
@@ -18,56 +23,41 @@ func sign(conf *signConfig) error {
 		return errors.Errorf("Both --transaction and --transaction-file cannot be passed at the same time")
 	}
 
-	keysFile, err := keys.ReadKeysFile(conf.NetParams(), conf.KeysFile)
-	if err != nil {
-		return err
-	}
-	privateKeys, err := keysFile.DecryptMnemonics(conf.Password)
-	if err != nil {
-		return err
-	}
-
-	transactionsHex := conf.Transaction
+	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)
 		}
-		transactionsHex = strings.TrimSpace(string(transactionHexBytes))
+		transactionHex = strings.TrimSpace(string(transactionHexBytes))
 	}
-	partiallySignedTransactions, err := decodeTransactionsFromHex(transactionsHex)
+
+	partiallySignedTransaction, err := hex.DecodeString(transactionHex)
 	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
-		}
+	privateKeys, err := keysFile.DecryptMnemonics(conf.Password)
+	if err != nil {
+		return err
 	}
 
-	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
-		}
+	updatedPartiallySignedTransaction, err := libkaspawallet.Sign(conf.NetParams(), privateKeys, partiallySignedTransaction, keysFile.ECDSA)
+	if err != nil {
+		return err
 	}
 
-	if areAllTransactionsFullySigned {
+	isFullySigned, err := libkaspawallet.IsTransactionFullySigned(updatedPartiallySignedTransaction)
+	if err != nil {
+		return err
+	}
+
+	if isFullySigned {
 		fmt.Println("The transaction is signed and ready to broadcast")
 	} else {
 		fmt.Println("Successfully signed transaction")
 	}
 
-	fmt.Println("Transaction: ")
-	fmt.Println(encodeTransactionsToHex(updatedPartiallySignedTransactions))
+	fmt.Printf("Transaction: %x\n", updatedPartiallySignedTransaction)
 	return nil
 }

cmd/kaspawallet/transactions_hex_encoding.go

@@ -1,33 +0,0 @@
-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.18-alpine AS build
+FROM golang:1.16-alpine AS build
 
 RUN mkdir -p /go/src/github.com/kaspanet/kaspad
 

domain/consensus/consensus.go

@@ -1,6 +1,8 @@
 package consensus
 
 import (
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/util/staging"
 	"math/big"
 	"sync"
 
@@ -8,8 +10,6 @@ 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
-	reachabilityManager   model.ReachabilityManager
+	reachabilityManagers  []model.ReachabilityManager
 	finalityManager       model.FinalityManager
 	pruningProofManager   model.PruningProofManager
 
@@ -49,7 +49,7 @@ type consensus struct {
 	consensusStateStore                 model.ConsensusStateStore
 	headersSelectedTipStore             model.HeaderSelectedTipStore
 	multisetStore                       model.MultisetStore
-	reachabilityDataStore               model.ReachabilityDataStore
+	reachabilityDataStores              []model.ReachabilityDataStore
 	utxoDiffStore                       model.UTXODiffStore
 	finalityStore                       model.FinalityStore
 	headersSelectedChainStore           model.HeadersSelectedChainStore
@@ -83,9 +83,11 @@ 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)
-		err = s.reachabilityManager.Init(stagingArea)
-		if err != nil {
-			return err
+		for _, reachabilityManager := range s.reachabilityManagers {
+			err = reachabilityManager.Init(stagingArea)
+			if err != nil {
+				return err
+			}
 		}
 
 		for _, dagTopologyManager := range s.dagTopologyManagers {
@@ -150,18 +152,6 @@ 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)
 }
 
@@ -353,25 +343,6 @@ 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()
@@ -730,7 +701,7 @@ func (s *consensus) Anticone(blockHash *externalapi.DomainHash) ([]*externalapi.
 		return nil, err
 	}
 
-	return s.dagTraversalManager.AnticoneFromBlocks(stagingArea, tips, blockHash, 0)
+	return s.dagTraversalManager.AnticoneFromBlocks(stagingArea, tips, blockHash)
 }
 
 func (s *consensus) EstimateNetworkHashesPerSecond(startHash *externalapi.DomainHash, windowSize int) (uint64, error) {
@@ -750,25 +721,7 @@ 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.
-	// 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
+	return s.consensusStateManager.ResolveVirtual(100)
 }
 
 func (s *consensus) BuildPruningPointProof() (*externalapi.PruningPointProof, error) {

domain/consensus/datastructures/blockrelationstore/block_relation_store.go

@@ -75,11 +75,6 @@ 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,12 +69,6 @@ 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,7 +10,6 @@ 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")
@@ -299,17 +298,11 @@ 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,27 +41,6 @@ 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,14 +7,11 @@ 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"
@@ -76,7 +73,7 @@ type Config struct {
 // Factory instantiates new Consensuses
 type Factory interface {
 	NewConsensus(config *Config, db infrastructuredatabase.Database, dbPrefix *prefix.Prefix) (
-		externalapi.Consensus, bool, error)
+		externalapi.Consensus, error)
 	NewTestConsensus(config *Config, testName string) (
 		tc testapi.TestConsensus, teardown func(keepDataDir bool), err error)
 
@@ -108,7 +105,7 @@ func NewFactory() Factory {
 
 // NewConsensus instantiates a new Consensus
 func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Database, dbPrefix *prefix.Prefix) (
-	consensusInstance externalapi.Consensus, shouldMigrate bool, err error) {
+	externalapi.Consensus, error) {
 
 	dbManager := consensusdatabase.New(db)
 	prefixBucket := consensusdatabase.MakeBucket(dbPrefix.Serialize())
@@ -131,11 +128,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, false, err
+		return nil, err
 	}
 	blockHeaderStore, err := blockheaderstore.New(dbManager, prefixBucket, 10_000, preallocateCaches)
 	if err != nil {
-		return nil, false, err
+		return nil, err
 	}
 
 	blockStatusStore := blockstatusstore.New(prefixBucket, pruningWindowSizePlusFinalityDepthForCache, preallocateCaches)
@@ -150,35 +147,11 @@ 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)
-	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)
+	reachabilityManagers, dagTopologyManagers, ghostdagManagers, dagTraversalManagers := f.dagProcesses(config, dbManager, blockHeaderStore, daaWindowStore, windowHeapSliceStore, blockRelationStores, reachabilityDataStores, ghostdagDataStores)
 
 	blockRelationStore := blockRelationStores[0]
-
+	reachabilityDataStore := reachabilityDataStores[0]
 	ghostdagDataStore := ghostdagDataStores[0]
 
 	dagTopologyManager := dagTopologyManagers[0]
@@ -198,9 +171,6 @@ 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,
@@ -210,12 +180,14 @@ 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,
-		txMassCalculator)
+		daaBlocksStore)
 	difficultyManager := f.difficultyConstructor(
 		dbManager,
 		ghostdagManager,
@@ -253,7 +225,6 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		dagTopologyManager,
 		finalityStore,
 		ghostdagDataStore,
-		pruningStore,
 		genesisHash,
 		config.FinalityDepth())
 	mergeDepthManager := mergedepthmanager.New(
@@ -291,7 +262,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		pruningStore,
 		daaBlocksStore)
 	if err != nil {
-		return nil, false, err
+		return nil, err
 	}
 
 	pruningManager := pruningmanager.New(
@@ -346,7 +317,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		dagTraversalManager,
 		coinbaseManager,
 		mergeDepthManager,
-		reachabilityManager,
+		reachabilityManagers,
 		finalityManager,
 		blockParentBuilder,
 		pruningManager,
@@ -360,8 +331,6 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		reachabilityDataStore,
 		consensusStateStore,
 		daaBlocksStore,
-
-		txMassCalculator,
 	)
 
 	syncManager := syncmanager.New(
@@ -410,7 +379,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		pruningManager,
 		blockValidator,
 		dagTopologyManager,
-		reachabilityManager,
+		reachabilityManagers,
 		difficultyManager,
 		pastMedianTimeManager,
 		coinbaseManager,
@@ -438,10 +407,9 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		dbManager,
 		dagTopologyManagers,
 		ghostdagManagers,
-		reachabilityManager,
+		reachabilityManagers,
 		dagTraversalManagers,
 		parentsManager,
-		pruningManager,
 
 		ghostdagDataStores,
 		pruningStore,
@@ -449,8 +417,6 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		blockStatusStore,
 		finalityStore,
 		consensusStateStore,
-		blockRelationStore,
-		reachabilityDataStore,
 
 		genesisHash,
 		config.K,
@@ -480,7 +446,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		headerTipsManager:     headerTipsManager,
 		mergeDepthManager:     mergeDepthManager,
 		pruningManager:        pruningManager,
-		reachabilityManager:   reachabilityManager,
+		reachabilityManagers:  reachabilityManagers,
 		finalityManager:       finalityManager,
 		pruningProofManager:   pruningProofManager,
 
@@ -494,7 +460,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		consensusStateStore:                 consensusStateStore,
 		headersSelectedTipStore:             headersSelectedTipStore,
 		multisetStore:                       multisetStore,
-		reachabilityDataStore:               reachabilityDataStore,
+		reachabilityDataStores:              reachabilityDataStores,
 		utxoDiffStore:                       utxoDiffStore,
 		finalityStore:                       finalityStore,
 		headersSelectedChainStore:           headersSelectedChainStore,
@@ -502,40 +468,25 @@ 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, false, err
+		return nil, err
 	}
 
 	err = consensusStateManager.RecoverUTXOIfRequired()
 	if err != nil {
-		return nil, false, err
+		return nil, err
 	}
 	err = pruningManager.ClearImportedPruningPointData()
 	if err != nil {
-		return nil, false, err
+		return nil, err
 	}
 	err = pruningManager.UpdatePruningPointIfRequired()
 	if err != nil {
-		return nil, false, err
+		return nil, err
 	}
 
-	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
+	return c, nil
 }
 
 func (f *factory) NewTestConsensus(config *Config, testName string) (
@@ -562,15 +513,11 @@ func (f *factory) NewTestConsensus(config *Config, testName string) (
 	}
 
 	testConsensusDBPrefix := &prefix.Prefix{}
-	consensusAsInterface, shouldMigrate, err := f.NewConsensus(config, db, testConsensusDBPrefix)
+	consensusAsInterface, 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)
@@ -581,7 +528,7 @@ func (f *factory) NewTestConsensus(config *Config, testName string) (
 		database:                  db,
 		testConsensusStateManager: testConsensusStateManager,
 		testReachabilityManager: reachabilitymanager.NewTestReachabilityManager(consensusAsImplementation.
-			reachabilityManager),
+			reachabilityManagers[0]),
 		testTransactionValidator: testTransactionValidator,
 	}
 	tstConsensus.testBlockBuilder = blockbuilder.NewTestBlockBuilder(consensusAsImplementation.blockBuilder, tstConsensus)
@@ -658,8 +605,8 @@ func (f *factory) dagProcesses(config *Config,
 	windowHeapSliceStore model.WindowHeapSliceStore,
 	blockRelationStores []model.BlockRelationStore,
 	reachabilityDataStores []model.ReachabilityDataStore,
-	ghostdagDataStores []model.GHOSTDAGDataStore,
-	isOldReachabilityInitialized bool) (
+	ghostdagDataStores []model.GHOSTDAGDataStore) (
+	[]model.ReachabilityManager,
 	[]model.DAGTopologyManager,
 	[]model.GHOSTDAGManager,
 	[]model.DAGTraversalManager,
@@ -670,20 +617,11 @@ 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++ {
-		if isOldReachabilityInitialized {
-			reachabilityManagers[i] = reachabilitymanager.New(
-				dbManager,
-				ghostdagDataStores[i],
-				reachabilityDataStores[i])
-		} else {
-			reachabilityManagers[i] = newReachabilityManager
-		}
+		reachabilityManagers[i] = reachabilitymanager.New(
+			dbManager,
+			ghostdagDataStores[i],
+			reachabilityDataStores[i])
 
 		dagTopologyManagers[i] = dagtopologymanager.New(
 			dbManager,
@@ -703,7 +641,7 @@ func (f *factory) dagProcesses(config *Config,
 			dbManager,
 			dagTopologyManagers[i],
 			ghostdagDataStores[i],
-			reachabilityManagers[i],
+			reachabilityDataStores[i],
 			ghostdagManagers[i],
 			daaWindowStore,
 			windowHeapSliceStore,
@@ -711,5 +649,5 @@ func (f *factory) dagProcesses(config *Config,
 			config.DifficultyAdjustmentWindowSize)
 	}
 
-	return dagTopologyManagers, ghostdagManagers, dagTraversalManagers
+	return reachabilityManagers, dagTopologyManagers, ghostdagManagers, dagTraversalManagers
 }

domain/consensus/factory_test.go

@@ -24,12 +24,8 @@ func TestNewConsensus(t *testing.T) {
 		t.Fatalf("error in NewLevelDB: %s", err)
 	}
 
-	_, shouldMigrate, err := f.NewConsensus(config, db, &prefix.Prefix{})
+	_, 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,7 +5,3 @@ 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,5 +80,4 @@ type MutableBlockHeader interface {
 	ToImmutable() BlockHeader
 	SetNonce(nonce uint64)
 	SetTimeInMilliseconds(timeInMilliseconds int64)
-	SetHashMerkleRoot(hashMerkleRoot *DomainHash)
 }

domain/consensus/model/externalapi/blocktemplate.go

@@ -1,17 +0,0 @@
-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,7 +1,5 @@
 package externalapi
 
-import "bytes"
-
 // DomainCoinbaseData contains data by which a coinbase transaction
 // is built
 type DomainCoinbaseData struct {
@@ -23,16 +21,3 @@ 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,7 +4,6 @@ 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
@@ -21,7 +20,6 @@ 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,19 +229,6 @@ 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
@@ -262,7 +249,11 @@ func (output *DomainTransactionOutput) Equal(other *DomainTransactionOutput) boo
 		return false
 	}
 
-	return output.ScriptPublicKey.Equal(other.ScriptPublicKey)
+	if !bytes.Equal(output.ScriptPublicKey.Script, other.ScriptPublicKey.Script) {
+		return false
+	}
+
+	return true
 }
 
 // Clone returns a clone of DomainTransactionOutput

domain/consensus/model/interface_datastructures_blockrelationstore.go

@@ -9,5 +9,4 @@ 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,5 +8,4 @@ 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)
 }