added relay hash to the log print

.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,11 +152,6 @@ const (
 	CmdVirtualDaaScoreChangedNotificationMessage
 	CmdGetBalancesByAddressesRequestMessage
 	CmdGetBalancesByAddressesResponseMessage
-	CmdNotifyNewBlockTemplateRequestMessage
-	CmdNotifyNewBlockTemplateResponseMessage
-	CmdNewBlockTemplateNotificationMessage
-	CmdGetMempoolEntriesByAddressesRequestMessage
-	CmdGetMempoolEntriesByAddressesResponseMessage
 )
 
 // ProtocolMessageCommandToString maps all MessageCommands to their string representation
@@ -204,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
@@ -291,11 +278,6 @@ var RPCMessageCommandToString = map[MessageCommand]string{
 	CmdVirtualDaaScoreChangedNotificationMessage:                  "VirtualDaaScoreChangedNotification",
 	CmdGetBalancesByAddressesRequestMessage:                       "GetBalancesByAddressesRequest",
 	CmdGetBalancesByAddressesResponseMessage:                      "GetBalancesByAddressesResponse",
-	CmdNotifyNewBlockTemplateRequestMessage:                       "NotifyNewBlockTemplateRequest",
-	CmdNotifyNewBlockTemplateResponseMessage:                      "NotifyNewBlockTemplateResponse",
-	CmdNewBlockTemplateNotificationMessage:                        "NewBlockTemplateNotification",
-	CmdGetMempoolEntriesByAddressesRequestMessage:                 "CmdGetMempoolEntriesByAddressesRequest",
-	CmdGetMempoolEntriesByAddressesResponseMessage:                "CmdGetMempoolEntriesByAddressesResponse",
 }
 
 // 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_get_mempool_entries_by_addresses.go

@@ -1,48 +0,0 @@
-package appmessage
-
-// MempoolEntryByAddress represents MempoolEntries associated with some address
-type MempoolEntryByAddress struct {
-	Address   string
-	Receiving []*MempoolEntry
-	Sending   []*MempoolEntry
-}
-
-// GetMempoolEntriesByAddressesRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetMempoolEntriesByAddressesRequestMessage struct {
-	baseMessage
-	Addresses []string
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetMempoolEntriesByAddressesRequestMessage) Command() MessageCommand {
-	return CmdGetMempoolEntriesByAddressesRequestMessage
-}
-
-// NewGetMempoolEntriesByAddressesRequestMessage returns a instance of the message
-func NewGetMempoolEntriesByAddressesRequestMessage(addresses []string) *GetMempoolEntriesByAddressesRequestMessage {
-	return &GetMempoolEntriesByAddressesRequestMessage{
-		Addresses: addresses,
-	}
-}
-
-// GetMempoolEntriesByAddressesResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetMempoolEntriesByAddressesResponseMessage struct {
-	baseMessage
-	Entries []*MempoolEntryByAddress
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetMempoolEntriesByAddressesResponseMessage) Command() MessageCommand {
-	return CmdGetMempoolEntriesByAddressesResponseMessage
-}
-
-// NewGetMempoolEntriesByAddressesResponseMessage returns a instance of the message
-func NewGetMempoolEntriesByAddressesResponseMessage(entries []*MempoolEntryByAddress) *GetMempoolEntriesByAddressesResponseMessage {
-	return &GetMempoolEntriesByAddressesResponseMessage{
-		Entries: entries,
-	}
-}

app/appmessage/rpc_get_virtual_selected_parent_chain_from_block.go

@@ -4,8 +4,7 @@ package appmessage
 // its respective RPC message
 type GetVirtualSelectedParentChainFromBlockRequestMessage struct {
 	baseMessage
-	StartHash                     string
-	IncludeAcceptedTransactionIDs bool
+	StartHash string
 }
 
 // Command returns the protocol command string for the message
@@ -14,29 +13,18 @@ func (msg *GetVirtualSelectedParentChainFromBlockRequestMessage) Command() Messa
 }
 
 // NewGetVirtualSelectedParentChainFromBlockRequestMessage returns a instance of the message
-func NewGetVirtualSelectedParentChainFromBlockRequestMessage(
-	startHash string, includeAcceptedTransactionIDs bool) *GetVirtualSelectedParentChainFromBlockRequestMessage {
-
+func NewGetVirtualSelectedParentChainFromBlockRequestMessage(startHash string) *GetVirtualSelectedParentChainFromBlockRequestMessage {
 	return &GetVirtualSelectedParentChainFromBlockRequestMessage{
-		StartHash:                     startHash,
-		IncludeAcceptedTransactionIDs: includeAcceptedTransactionIDs,
+		StartHash: startHash,
 	}
 }
 
-// AcceptedTransactionIDs is a part of the GetVirtualSelectedParentChainFromBlockResponseMessage and
-// VirtualSelectedParentChainChangedNotificationMessage appmessages
-type AcceptedTransactionIDs struct {
-	AcceptingBlockHash     string
-	AcceptedTransactionIDs []string
-}
-
 // GetVirtualSelectedParentChainFromBlockResponseMessage is an appmessage corresponding to
 // its respective RPC message
 type GetVirtualSelectedParentChainFromBlockResponseMessage struct {
 	baseMessage
 	RemovedChainBlockHashes []string
 	AddedChainBlockHashes   []string
-	AcceptedTransactionIDs  []*AcceptedTransactionIDs
 
 	Error *RPCError
 }
@@ -48,11 +36,10 @@ func (msg *GetVirtualSelectedParentChainFromBlockResponseMessage) Command() Mess
 
 // NewGetVirtualSelectedParentChainFromBlockResponseMessage returns a instance of the message
 func NewGetVirtualSelectedParentChainFromBlockResponseMessage(removedChainBlockHashes,
-	addedChainBlockHashes []string, acceptedTransactionIDs []*AcceptedTransactionIDs) *GetVirtualSelectedParentChainFromBlockResponseMessage {
+	addedChainBlockHashes []string) *GetVirtualSelectedParentChainFromBlockResponseMessage {
 
 	return &GetVirtualSelectedParentChainFromBlockResponseMessage{
 		RemovedChainBlockHashes: removedChainBlockHashes,
 		AddedChainBlockHashes:   addedChainBlockHashes,
-		AcceptedTransactionIDs:  acceptedTransactionIDs,
 	}
 }

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/appmessage/rpc_notify_virtual_selected_parent_chain_changed.go

@@ -4,7 +4,6 @@ package appmessage
 // its respective RPC message
 type NotifyVirtualSelectedParentChainChangedRequestMessage struct {
 	baseMessage
-	IncludeAcceptedTransactionIDs bool
 }
 
 // Command returns the protocol command string for the message
@@ -12,13 +11,9 @@ func (msg *NotifyVirtualSelectedParentChainChangedRequestMessage) Command() Mess
 	return CmdNotifyVirtualSelectedParentChainChangedRequestMessage
 }
 
-// NewNotifyVirtualSelectedParentChainChangedRequestMessage returns an instance of the message
-func NewNotifyVirtualSelectedParentChainChangedRequestMessage(
-	includeAcceptedTransactionIDs bool) *NotifyVirtualSelectedParentChainChangedRequestMessage {
-
-	return &NotifyVirtualSelectedParentChainChangedRequestMessage{
-		IncludeAcceptedTransactionIDs: includeAcceptedTransactionIDs,
-	}
+// NewNotifyVirtualSelectedParentChainChangedRequestMessage returns a instance of the message
+func NewNotifyVirtualSelectedParentChainChangedRequestMessage() *NotifyVirtualSelectedParentChainChangedRequestMessage {
+	return &NotifyVirtualSelectedParentChainChangedRequestMessage{}
 }
 
 // NotifyVirtualSelectedParentChainChangedResponseMessage is an appmessage corresponding to
@@ -44,7 +39,6 @@ type VirtualSelectedParentChainChangedNotificationMessage struct {
 	baseMessage
 	RemovedChainBlockHashes []string
 	AddedChainBlockHashes   []string
-	AcceptedTransactionIDs  []*AcceptedTransactionIDs
 }
 
 // Command returns the protocol command string for the message
@@ -54,11 +48,10 @@ func (msg *VirtualSelectedParentChainChangedNotificationMessage) Command() Messa
 
 // NewVirtualSelectedParentChainChangedNotificationMessage returns a instance of the message
 func NewVirtualSelectedParentChainChangedNotificationMessage(removedChainBlockHashes,
-	addedChainBlocks []string, acceptedTransactionIDs []*AcceptedTransactionIDs) *VirtualSelectedParentChainChangedNotificationMessage {
+	addedChainBlocks []string) *VirtualSelectedParentChainChangedNotificationMessage {
 
 	return &VirtualSelectedParentChainChangedNotificationMessage{
 		RemovedChainBlockHashes: removedChainBlockHashes,
 		AddedChainBlockHashes:   addedChainBlocks,
-		AcceptedTransactionIDs:  acceptedTransactionIDs,
 	}
 }

app/component_manager.go

@@ -4,8 +4,6 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-
 	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
 
 	"github.com/kaspanet/kaspad/app/protocol"
@@ -69,7 +67,6 @@ func (a *ComponentManager) Stop() {
 	}
 
 	a.protocolManager.Close()
-	close(a.protocolManager.Context().Domain().ConsensusEventsChannel())
 
 	return
 }
@@ -121,7 +118,7 @@ func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database,
 	if err != nil {
 		return nil, err
 	}
-	rpcManager := setupRPC(cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, utxoIndex, domain.ConsensusEventsChannel(), interrupt)
+	rpcManager := setupRPC(cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, utxoIndex, interrupt)
 
 	return &ComponentManager{
 		cfg:               cfg,
@@ -142,7 +139,6 @@ func setupRPC(
 	connectionManager *connmanager.ConnectionManager,
 	addressManager *addressmanager.AddressManager,
 	utxoIndex *utxoindex.UTXOIndex,
-	consensusEventsChan chan externalapi.ConsensusEvent,
 	shutDownChan chan<- struct{},
 ) *rpc.Manager {
 
@@ -154,10 +150,10 @@ func setupRPC(
 		connectionManager,
 		addressManager,
 		utxoIndex,
-		consensusEventsChan,
 		shutDownChan,
 	)
-	protocolManager.SetOnNewBlockTemplateHandler(rpcManager.NotifyNewBlockTemplate)
+	protocolManager.SetOnVirtualChange(rpcManager.NotifyVirtualChange)
+	protocolManager.SetOnBlockAddedToDAGHandler(rpcManager.NotifyBlockAddedToDAG)
 	protocolManager.SetOnPruningPointUTXOSetOverrideHandler(rpcManager.NotifyPruningPointUTXOSetOverride)
 
 	return rpcManager

app/protocol/flowcontext/blocks.go

@@ -16,42 +16,53 @@ import (
 // OnNewBlock updates the mempool after a new block arrival, and
 // relays newly unorphaned transactions and possibly rebroadcast
 // manually added transactions when not in IBD.
-func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock) error {
+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)
 
-	unorphanedBlocks, err := f.UnorphanBlocks(block)
+	unorphaningResults, err := f.UnorphanBlocks(block)
 	if err != nil {
 		return err
 	}
 
-	log.Debugf("OnNewBlock: block %s unorphaned %d blocks", hash, len(unorphanedBlocks))
+	log.Debugf("OnNewBlock: block %s unorphaned %d blocks", hash, len(unorphaningResults))
 
 	newBlocks := []*externalapi.DomainBlock{block}
-	newBlocks = append(newBlocks, unorphanedBlocks...)
+	newVirtualChangeSets := []*externalapi.VirtualChangeSet{virtualChangeSet}
+	for _, unorphaningResult := range unorphaningResults {
+		newBlocks = append(newBlocks, unorphaningResult.block)
+		newVirtualChangeSets = append(newVirtualChangeSets, unorphaningResult.virtualChangeSet)
+	}
 
 	allAcceptedTransactions := make([]*externalapi.DomainTransaction, 0)
-	for _, newBlock := range newBlocks {
+	for i, newBlock := range newBlocks {
 		log.Debugf("OnNewBlock: passing block %s transactions to mining manager", hash)
 		acceptedTransactions, err := f.Domain().MiningManager().HandleNewBlockTransactions(newBlock.Transactions)
 		if err != nil {
 			return err
 		}
 		allAcceptedTransactions = append(allAcceptedTransactions, acceptedTransactions...)
+
+		if f.onBlockAddedToDAGHandler != nil {
+			log.Debugf("OnNewBlock: calling f.onBlockAddedToDAGHandler for block %s", hash)
+			virtualChangeSet = newVirtualChangeSets[i]
+			err := f.onBlockAddedToDAGHandler(newBlock, virtualChangeSet)
+			if err != nil {
+				return err
+			}
+		}
 	}
 
 	return f.broadcastTransactionsAfterBlockAdded(newBlocks, allAcceptedTransactions)
 }
 
-// OnNewBlockTemplate calls the handler function whenever a new block template is available for miners.
-func (f *FlowContext) OnNewBlockTemplate() error {
-	// Clear current template cache. Note we call this even if the handler is nil, in order to keep the
-	// state consistent without dependency on external event registration
-	f.Domain().MiningManager().ClearBlockTemplate()
-	if f.onNewBlockTemplateHandler != nil {
-		return f.onNewBlockTemplateHandler()
+// OnVirtualChange calls the handler function whenever the virtual block changes.
+func (f *FlowContext) OnVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error {
+	if f.onVirtualChangeHandler != nil && virtualChangeSet != nil {
+		return f.onVirtualChangeHandler(virtualChangeSet)
 	}
 
 	return nil
@@ -107,18 +118,14 @@ func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
 		return protocolerrors.Errorf(false, "cannot add header only block")
 	}
 
-	_, err := f.Domain().Consensus().ValidateAndInsertBlock(block, true)
+	virtualChangeSet, err := f.Domain().Consensus().ValidateAndInsertBlock(block, true)
 	if err != nil {
 		if errors.As(err, &ruleerrors.RuleError{}) {
 			log.Warnf("Validation failed for block %s: %s", consensushashing.BlockHash(block), err)
 		}
 		return err
 	}
-	err = f.OnNewBlockTemplate()
-	if err != nil {
-		return err
-	}
-	err = f.OnNewBlock(block)
+	err = f.OnNewBlock(block, virtualChangeSet)
 	if err != nil {
 		return err
 	}
@@ -143,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

@@ -18,8 +18,12 @@ import (
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
 )
 
-// OnNewBlockTemplateHandler is a handler function that's triggered when a new block template is available
-type OnNewBlockTemplateHandler func() error
+// OnBlockAddedToDAGHandler is a handler function that's triggered
+// when a block is added to the DAG
+type OnBlockAddedToDAGHandler func(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error
+
+// OnVirtualChangeHandler is a handler function that's triggered when the virtual changes
+type OnVirtualChangeHandler func(virtualChangeSet *externalapi.VirtualChangeSet) error
 
 // OnPruningPointUTXOSetOverrideHandler is a handle function that's triggered whenever the UTXO set
 // resets due to pruning point change via IBD.
@@ -40,7 +44,8 @@ type FlowContext struct {
 
 	timeStarted int64
 
-	onNewBlockTemplateHandler            OnNewBlockTemplateHandler
+	onVirtualChangeHandler               OnVirtualChangeHandler
+	onBlockAddedToDAGHandler             OnBlockAddedToDAGHandler
 	onPruningPointUTXOSetOverrideHandler OnPruningPointUTXOSetOverrideHandler
 	onTransactionAddedToMempoolHandler   OnTransactionAddedToMempoolHandler
 
@@ -97,14 +102,14 @@ func (f *FlowContext) ShutdownChan() <-chan struct{} {
 	return f.shutdownChan
 }
 
-// IsNearlySynced returns whether current consensus is considered synced or close to being synced.
-func (f *FlowContext) IsNearlySynced() (bool, error) {
-	return f.Domain().Consensus().IsNearlySynced()
+// SetOnVirtualChangeHandler sets the onVirtualChangeHandler handler
+func (f *FlowContext) SetOnVirtualChangeHandler(onVirtualChangeHandler OnVirtualChangeHandler) {
+	f.onVirtualChangeHandler = onVirtualChangeHandler
 }
 
-// SetOnNewBlockTemplateHandler sets the onNewBlockTemplateHandler handler
-func (f *FlowContext) SetOnNewBlockTemplateHandler(onNewBlockTemplateHandler OnNewBlockTemplateHandler) {
-	f.onNewBlockTemplateHandler = onNewBlockTemplateHandler
+// SetOnBlockAddedToDAGHandler sets the onBlockAddedToDAG handler
+func (f *FlowContext) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler OnBlockAddedToDAGHandler) {
+	f.onBlockAddedToDAGHandler = onBlockAddedToDAGHandler
 }
 
 // SetOnPruningPointUTXOSetOverrideHandler sets the onPruningPointUTXOSetOverrideHandler handler

app/protocol/flowcontext/network.go

@@ -72,10 +72,3 @@ func (f *FlowContext) Peers() []*peerpkg.Peer {
 	}
 	return peers
 }
-
-// HasPeers returns whether there are currently active peers
-func (f *FlowContext) HasPeers() bool {
-	f.peersMutex.RLock()
-	defer f.peersMutex.RUnlock()
-	return len(f.peers) > 0
-}

app/protocol/flowcontext/orphans.go

@@ -15,6 +15,12 @@ import (
 // on: 2^orphanResolutionRange * PHANTOM K.
 const maxOrphans = 600
 
+// UnorphaningResult is the result of unorphaning a block
+type UnorphaningResult struct {
+	block            *externalapi.DomainBlock
+	virtualChangeSet *externalapi.VirtualChangeSet
+}
+
 // AddOrphan adds the block to the orphan set
 func (f *FlowContext) AddOrphan(orphanBlock *externalapi.DomainBlock) {
 	f.orphansMutex.Lock()
@@ -51,7 +57,7 @@ func (f *FlowContext) IsOrphan(blockHash *externalapi.DomainHash) bool {
 }
 
 // UnorphanBlocks removes the block from the orphan set, and remove all of the blocks that are not orphans anymore.
-func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*externalapi.DomainBlock, error) {
+func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*UnorphaningResult, error) {
 	f.orphansMutex.Lock()
 	defer f.orphansMutex.Unlock()
 
@@ -60,7 +66,7 @@ func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*ext
 	rootBlockHash := consensushashing.BlockHash(rootBlock)
 	processQueue := f.addChildOrphansToProcessQueue(rootBlockHash, []externalapi.DomainHash{})
 
-	var unorphanedBlocks []*externalapi.DomainBlock
+	var unorphaningResults []*UnorphaningResult
 	for len(processQueue) > 0 {
 		var orphanHash externalapi.DomainHash
 		orphanHash, processQueue = processQueue[0], processQueue[1:]
@@ -84,18 +90,21 @@ func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*ext
 			}
 		}
 		if canBeUnorphaned {
-			unorphaningSucceeded, err := f.unorphanBlock(orphanHash)
+			virtualChangeSet, unorphaningSucceeded, err := f.unorphanBlock(orphanHash)
 			if err != nil {
 				return nil, err
 			}
 			if unorphaningSucceeded {
-				unorphanedBlocks = append(unorphanedBlocks, orphanBlock)
+				unorphaningResults = append(unorphaningResults, &UnorphaningResult{
+					block:            orphanBlock,
+					virtualChangeSet: virtualChangeSet,
+				})
 				processQueue = f.addChildOrphansToProcessQueue(&orphanHash, processQueue)
 			}
 		}
 	}
 
-	return unorphanedBlocks, nil
+	return unorphaningResults, nil
 }
 
 // addChildOrphansToProcessQueue finds all child orphans of `blockHash`
@@ -134,24 +143,24 @@ func (f *FlowContext) findChildOrphansOfBlock(blockHash *externalapi.DomainHash)
 	return childOrphans
 }
 
-func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) (bool, error) {
+func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) (*externalapi.VirtualChangeSet, bool, error) {
 	orphanBlock, ok := f.orphans[orphanHash]
 	if !ok {
-		return false, errors.Errorf("attempted to unorphan a non-orphan block %s", orphanHash)
+		return nil, false, errors.Errorf("attempted to unorphan a non-orphan block %s", orphanHash)
 	}
 	delete(f.orphans, orphanHash)
 
-	_, err := f.domain.Consensus().ValidateAndInsertBlock(orphanBlock, true)
+	virtualChangeSet, err := f.domain.Consensus().ValidateAndInsertBlock(orphanBlock, true)
 	if err != nil {
 		if errors.As(err, &ruleerrors.RuleError{}) {
 			log.Warnf("Validation failed for orphan block %s: %s", orphanHash, err)
-			return false, nil
+			return nil, false, nil
 		}
-		return false, err
+		return nil, false, err
 	}
 
 	log.Infof("Unorphaned block %s", orphanHash)
-	return true, nil
+	return virtualChangeSet, true, nil
 }
 
 // GetOrphanRoots returns the roots of the missing ancestors DAG of the given orphan

app/protocol/flowcontext/should_mine.go

@@ -0,0 +1,47 @@
+package flowcontext
+
+import "github.com/kaspanet/kaspad/util/mstime"
+
+const (
+	maxSelectedParentTimeDiffToAllowMiningInMilliSeconds = 60 * 60 * 1000 // 1 Hour
+)
+
+// ShouldMine returns whether it's ok to use block template from this node
+// for mining purposes.
+func (f *FlowContext) ShouldMine() (bool, error) {
+	peers := f.Peers()
+	if len(peers) == 0 {
+		log.Debugf("The node is not connected, so ShouldMine returns false")
+		return false, nil
+	}
+
+	if f.IsIBDRunning() {
+		log.Debugf("IBD is running, so ShouldMine returns false")
+		return false, nil
+	}
+
+	virtualSelectedParent, err := f.domain.Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return false, err
+	}
+
+	if virtualSelectedParent.Equal(f.Config().NetParams().GenesisHash) {
+		return false, nil
+	}
+
+	virtualSelectedParentHeader, err := f.domain.Consensus().GetBlockHeader(virtualSelectedParent)
+	if err != nil {
+		return false, err
+	}
+
+	now := mstime.Now().UnixMilliseconds()
+	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 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/block_locator.go

@@ -21,7 +21,7 @@ func (flow *handleRelayInvsFlow) receiveBlockLocator() (blockLocatorHashes []*ex
 
 		switch message := message.(type) {
 		case *appmessage.MsgInvRelayBlock:
-			flow.invsQueue = append(flow.invsQueue, invRelayBlock{Hash: message.Hash, IsOrphanRoot: false})
+			flow.invsQueue = append(flow.invsQueue, message)
 		case *appmessage.MsgBlockLocator:
 			return message.BlockLocatorHashes, nil
 		default:

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

@@ -7,11 +7,9 @@ import (
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/hashset"
 	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/pkg/errors"
@@ -26,8 +24,8 @@ var orphanResolutionRange uint32 = 5
 type RelayInvsContext interface {
 	Domain() domain.Domain
 	Config() *config.Config
-	OnNewBlock(block *externalapi.DomainBlock) error
-	OnNewBlockTemplate() error
+	OnNewBlock(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error
+	OnVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error
 	OnPruningPointUTXOSetOverride() error
 	SharedRequestedBlocks() *flowcontext.SharedRequestedBlocks
 	Broadcast(message appmessage.Message) error
@@ -36,19 +34,13 @@ type RelayInvsContext interface {
 	IsOrphan(blockHash *externalapi.DomainHash) bool
 	IsIBDRunning() bool
 	IsRecoverableError(err error) bool
-	IsNearlySynced() (bool, error)
-}
-
-type invRelayBlock struct {
-	Hash         *externalapi.DomainHash
-	IsOrphanRoot bool
 }
 
 type handleRelayInvsFlow struct {
 	RelayInvsContext
 	incomingRoute, outgoingRoute *router.Route
 	peer                         *peerpkg.Peer
-	invsQueue                    []invRelayBlock
+	invsQueue                    []*appmessage.MsgInvRelayBlock
 }
 
 // HandleRelayInvs listens to appmessage.MsgInvRelayBlock messages, requests their corresponding blocks if they
@@ -61,7 +53,7 @@ func HandleRelayInvs(context RelayInvsContext, incomingRoute *router.Route, outg
 		incomingRoute:    incomingRoute,
 		outgoingRoute:    outgoingRoute,
 		peer:             peer,
-		invsQueue:        make([]invRelayBlock, 0),
+		invsQueue:        make([]*appmessage.MsgInvRelayBlock, 0),
 	}
 	err := flow.start()
 	// Currently, HandleRelayInvs flow is the only place where IBD is triggered, so the channel can be closed now
@@ -112,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)
@@ -144,36 +130,8 @@ func (flow *handleRelayInvsFlow) start() error {
 			continue
 		}
 
-		// Note we do not apply the heuristic below if inv was queued as an orphan root, since
-		// that means the process started by a proper and relevant relay block
-		if !inv.IsOrphanRoot {
-			// Check bounded merge depth to avoid requesting irrelevant data which cannot be merged under virtual
-			virtualMergeDepthRoot, err := flow.Domain().Consensus().VirtualMergeDepthRoot()
-			if err != nil {
-				return err
-			}
-			if !virtualMergeDepthRoot.Equal(model.VirtualGenesisBlockHash) {
-				mergeDepthRootHeader, err := flow.Domain().Consensus().GetBlockHeader(virtualMergeDepthRoot)
-				if err != nil {
-					return err
-				}
-				// Since `BlueWork` respects topology, this condition means that the relay
-				// block is not in the future of virtual's merge depth root, and thus cannot be merged unless
-				// other valid blocks Kosherize it, in which case it will be obtained once the merger is relayed
-				if block.Header.BlueWork().Cmp(mergeDepthRootHeader.BlueWork()) <= 0 {
-					log.Debugf("Block %s has lower blue work than virtual's merge root %s (%d <= %d), hence we are skipping it",
-						inv.Hash, virtualMergeDepthRoot, block.Header.BlueWork(), mergeDepthRootHeader.BlueWork())
-					continue
-				}
-			}
-		}
-
 		log.Debugf("Processing block %s", inv.Hash)
-		oldVirtualInfo, err := flow.Domain().Consensus().GetVirtualInfo()
-		if err != nil {
-			return err
-		}
-		missingParents, err := flow.processBlock(block)
+		missingParents, virtualChangeSet, err := flow.processBlock(block)
 		if err != nil {
 			if errors.Is(err, ruleerrors.ErrPrunedBlock) {
 				log.Infof("Ignoring pruned block %s", inv.Hash)
@@ -195,44 +153,13 @@ 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)
+		err = flow.OnNewBlock(block, virtualChangeSet)
 		if err != nil {
 			return err
 		}
@@ -248,24 +175,24 @@ func (flow *handleRelayInvsFlow) banIfBlockIsHeaderOnly(block *externalapi.Domai
 	return nil
 }
 
-func (flow *handleRelayInvsFlow) readInv() (invRelayBlock, error) {
+func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error) {
 	if len(flow.invsQueue) > 0 {
-		var inv invRelayBlock
+		var inv *appmessage.MsgInvRelayBlock
 		inv, flow.invsQueue = flow.invsQueue[0], flow.invsQueue[1:]
 		return inv, nil
 	}
 
 	msg, err := flow.incomingRoute.Dequeue()
 	if err != nil {
-		return invRelayBlock{}, err
+		return nil, err
 	}
 
-	msgInv, ok := msg.(*appmessage.MsgInvRelayBlock)
+	inv, ok := msg.(*appmessage.MsgInvRelayBlock)
 	if !ok {
-		return invRelayBlock{}, protocolerrors.Errorf(true, "unexpected %s message in the block relay handleRelayInvsFlow while "+
+		return nil, protocolerrors.Errorf(true, "unexpected %s message in the block relay handleRelayInvsFlow while "+
 			"expecting an inv message", msg.Command())
 	}
-	return invRelayBlock{Hash: msgInv.Hash, IsOrphanRoot: false}, nil
+	return inv, nil
 }
 
 func (flow *handleRelayInvsFlow) requestBlock(requestHash *externalapi.DomainHash) (*externalapi.DomainBlock, bool, error) {
@@ -310,7 +237,7 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock,
 
 		switch message := message.(type) {
 		case *appmessage.MsgInvRelayBlock:
-			flow.invsQueue = append(flow.invsQueue, invRelayBlock{Hash: message.Hash, IsOrphanRoot: false})
+			flow.invsQueue = append(flow.invsQueue, message)
 		case *appmessage.MsgBlock:
 			return message, nil
 		default:
@@ -319,25 +246,22 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock,
 	}
 }
 
-func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, error) {
+func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, *externalapi.VirtualChangeSet, error) {
 	blockHash := consensushashing.BlockHash(block)
-	_, err := flow.Domain().Consensus().ValidateAndInsertBlock(block, true)
+	virtualChangeSet, err := flow.Domain().Consensus().ValidateAndInsertBlock(block, true)
 	if err != nil {
 		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return nil, errors.Wrapf(err, "failed to process block %s", blockHash)
+			return nil, nil, errors.Wrapf(err, "failed to process block %s", blockHash)
 		}
 
 		missingParentsError := &ruleerrors.ErrMissingParents{}
 		if errors.As(err, missingParentsError) {
-			return missingParentsError.MissingParentHashes, nil
+			return missingParentsError.MissingParentHashes, nil, nil
 		}
-		// A duplicate block should not appear to the user as a warning and is already reported in the calling function
-		if !errors.Is(err, ruleerrors.ErrDuplicateBlock) {
-			log.Warnf("Rejected block %s from %s: %s", blockHash, flow.peer, err)
-		}
-		return nil, protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
+		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, nil
+	return nil, virtualChangeSet, nil
 }
 
 func (flow *handleRelayInvsFlow) relayBlock(block *externalapi.DomainBlock) error {
@@ -445,16 +369,12 @@ 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([]invRelayBlock, len(orphanRoots))
+	invMessages := make([]*appmessage.MsgInvRelayBlock, len(orphanRoots))
 	for i, root := range orphanRoots {
 		log.Debugf("Adding block %s missing ancestor %s to the invs queue", orphan, root)
-		invMessages[i] = invRelayBlock{Hash: root, IsOrphanRoot: true}
+		invMessages[i] = appmessage.NewMsgInvBlock(root)
 	}
 
 	flow.invsQueue = append(invMessages, flow.invsQueue...)

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,13 +6,16 @@ import (
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/logger"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/difficulty"
 	"github.com/pkg/errors"
+	"math/big"
 	"time"
 )
 
@@ -20,8 +23,8 @@ import (
 type IBDContext interface {
 	Domain() domain.Domain
 	Config() *config.Config
-	OnNewBlock(block *externalapi.DomainBlock) error
-	OnNewBlockTemplate() error
+	OnNewBlock(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error
+	OnVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error
 	OnPruningPointUTXOSetOverride() error
 	IsIBDRunning() bool
 	TrySetIBDRunning(ibdPeer *peerpkg.Peer) bool
@@ -63,6 +66,29 @@ func (flow *handleIBDFlow) start() error {
 }
 
 func (flow *handleIBDFlow) runIBDIfNotRunning(block *externalapi.DomainBlock) error {
+	highHash := consensushashing.BlockHash(block)
+
+	// Temp code to avoid IBD from lagging nodes publishing their side-chain
+	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
+	if err == nil {
+		virtualSelectedParentHeader, err := flow.Domain().Consensus().GetBlockHeader(virtualSelectedParent)
+		if err == nil {
+			if virtualSelectedParentHeader.DAAScore() > block.Header.DAAScore()+2641 {
+				virtualDifficulty := difficulty.CalcWork(virtualSelectedParentHeader.Bits())
+				var virtualSub, difficultyMul big.Int
+				if difficultyMul.Mul(virtualDifficulty, big.NewInt(180)).
+					Cmp(virtualSub.Sub(virtualSelectedParentHeader.BlueWork(), block.Header.BlueWork())) < 0 {
+					log.Criticalf("Avoiding IBD triggered by relay %s because it is coming from " +
+						"a deep (%d DAA score depth) side-chain which has much lower blue work (%d, %d)",
+						highHash,
+						virtualSelectedParentHeader.DAAScore()-block.Header.DAAScore(),
+						virtualSelectedParentHeader.BlueWork(), block.Header.BlueWork())
+					return nil
+				}
+			}
+		}
+	}
+
 	wasIBDNotRunning := flow.TrySetIBDRunning(flow.peer)
 	if !wasIBDNotRunning {
 		log.Debugf("IBD is already running")
@@ -75,19 +101,16 @@ 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()
+	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)
 
-	shouldDownloadHeadersProof, shouldSync, err := flow.shouldSyncAndShouldDownloadHeadersProof(
-		block, highestKnownSyncerChainHash)
+	shouldDownloadHeadersProof, shouldSync, err := flow.shouldSyncAndShouldDownloadHeadersProof(block, highestSharedBlockFound)
 	if err != nil {
 		return err
 	}
@@ -98,7 +121,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
 		}
@@ -111,162 +134,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 {
@@ -281,57 +169,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
@@ -349,11 +321,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
 
@@ -369,10 +336,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
 				}
@@ -386,70 +362,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) {
@@ -472,7 +389,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,
@@ -482,27 +399,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 {
@@ -566,7 +482,7 @@ func (flow *handleIBDFlow) receiveAndInsertPruningPointUTXOSet(
 
 			receivedChunkCount++
 			if receivedChunkCount%ibdBatchSize == 0 {
-				log.Infof("Received %d UTXO set chunks so far, totaling in %d UTXOs",
+				log.Debugf("Received %d UTXO set chunks so far, totaling in %d UTXOs",
 					receivedChunkCount, receivedUTXOCount)
 
 				requestNextPruningPointUTXOSetChunkMessage := appmessage.NewMsgRequestNextPruningPointUTXOSetChunk()
@@ -654,7 +570,7 @@ func (flow *handleIBDFlow) syncMissingBlockBodies(highHash *externalapi.DomainHa
 				return err
 			}
 
-			_, err = flow.Domain().Consensus().ValidateAndInsertBlock(block, false)
+			virtualChangeSet, err := flow.Domain().Consensus().ValidateAndInsertBlock(block, false)
 			if err != nil {
 				if errors.Is(err, ruleerrors.ErrDuplicateBlock) {
 					log.Debugf("Skipping IBD Block %s as it has already been added to the DAG", blockHash)
@@ -662,7 +578,7 @@ func (flow *handleIBDFlow) syncMissingBlockBodies(highHash *externalapi.DomainHa
 				}
 				return protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "invalid block %s", blockHash)
 			}
-			err = flow.OnNewBlock(block)
+			err = flow.OnNewBlock(block, virtualChangeSet)
 			if err != nil {
 				return err
 			}
@@ -705,17 +621,18 @@ func (flow *handleIBDFlow) resolveVirtual(estimatedVirtualDAAScoreTarget uint64)
 			}
 			log.Infof("Resolving virtual. Estimated progress: %d%%", percents)
 		}
-		_, isCompletelyResolved, err := flow.Domain().Consensus().ResolveVirtual()
+		virtualChangeSet, isCompletelyResolved, err := flow.Domain().Consensus().ResolveVirtual()
+		if err != nil {
+			return err
+		}
+
+		err = flow.OnVirtualChange(virtualChangeSet)
 		if err != nil {
 			return err
 		}
 
 		if isCompletelyResolved {
 			log.Infof("Resolved virtual")
-			err = flow.OnNewBlockTemplate()
-			if err != nil {
-				return err
-			}
 			return nil
 		}
 	}

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

@@ -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

@@ -2,11 +2,10 @@ package protocol
 
 import (
 	"fmt"
+	"github.com/kaspanet/kaspad/app/protocol/common"
 	"sync"
 	"sync/atomic"
 
-	"github.com/kaspanet/kaspad/app/protocol/common"
-
 	"github.com/pkg/errors"
 
 	"github.com/kaspanet/kaspad/domain"
@@ -91,9 +90,14 @@ func (m *Manager) runFlows(flows []*common.Flow, peer *peerpkg.Peer, errChan <-c
 	return <-errChan
 }
 
-// SetOnNewBlockTemplateHandler sets the onNewBlockTemplate handler
-func (m *Manager) SetOnNewBlockTemplateHandler(onNewBlockTemplateHandler flowcontext.OnNewBlockTemplateHandler) {
-	m.context.SetOnNewBlockTemplateHandler(onNewBlockTemplateHandler)
+// SetOnVirtualChange sets the onVirtualChangeHandler handler
+func (m *Manager) SetOnVirtualChange(onVirtualChangeHandler flowcontext.OnVirtualChangeHandler) {
+	m.context.SetOnVirtualChangeHandler(onVirtualChangeHandler)
+}
+
+// SetOnBlockAddedToDAGHandler sets the onBlockAddedToDAG handler
+func (m *Manager) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler flowcontext.OnBlockAddedToDAGHandler) {
+	m.context.SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler)
 }
 
 // SetOnPruningPointUTXOSetOverrideHandler sets the OnPruningPointUTXOSetOverride handler
@@ -106,6 +110,12 @@ func (m *Manager) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMemp
 	m.context.SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler)
 }
 
+// ShouldMine returns whether it's ok to use block template from this node
+// for mining purposes.
+func (m *Manager) ShouldMine() (bool, error) {
+	return m.context.ShouldMine()
+}
+
 // IsIBDRunning returns true if IBD is currently marked as running
 func (m *Manager) IsIBDRunning() bool {
 	return m.context.IsIBDRunning()

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"
 
@@ -23,7 +23,7 @@ func (m *Manager) routerInitializer(router *routerpkg.Router, netConnection *net
 	// errChan is used by the flow goroutines to return to runFlows when an error occurs.
 	// They are both initialized here and passed to register flows.
 	isStopping := uint32(0)
-	errChan := make(chan error, 1)
+	errChan := make(chan error)
 
 	receiveVersionRoute, sendVersionRoute, receiveReadyRoute := registerHandshakeRoutes(router)
 
@@ -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

@@ -12,7 +12,6 @@ import (
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-	"github.com/pkg/errors"
 )
 
 // Manager is an RPC manager
@@ -29,7 +28,6 @@ func NewManager(
 	connectionManager *connmanager.ConnectionManager,
 	addressManager *addressmanager.AddressManager,
 	utxoIndex *utxoindex.UTXOIndex,
-	consensusEventsChan chan externalapi.ConsensusEvent,
 	shutDownChan chan<- struct{}) *Manager {
 
 	manager := Manager{
@@ -46,90 +44,50 @@ func NewManager(
 	}
 	netAdapter.SetRPCRouterInitializer(manager.routerInitializer)
 
-	manager.initConsensusEventsHandler(consensusEventsChan)
-
 	return &manager
 }
 
-func (m *Manager) initConsensusEventsHandler(consensusEventsChan chan externalapi.ConsensusEvent) {
-	spawn("consensusEventsHandler", func() {
-		for {
-			consensusEvent, ok := <-consensusEventsChan
-			if !ok {
-				return
-			}
-			switch event := consensusEvent.(type) {
-			case *externalapi.VirtualChangeSet:
-				err := m.notifyVirtualChange(event)
-				if err != nil {
-					panic(err)
-				}
-			case *externalapi.BlockAdded:
-				err := m.notifyBlockAddedToDAG(event.Block)
-				if err != nil {
-					panic(err)
-				}
-			default:
-				panic(errors.Errorf("Got event of unsupported type %T", consensusEvent))
-			}
-		}
-	})
-}
-
-// notifyBlockAddedToDAG notifies the manager that a block has been added to the DAG
-func (m *Manager) notifyBlockAddedToDAG(block *externalapi.DomainBlock) error {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.notifyBlockAddedToDAG")
+// NotifyBlockAddedToDAG notifies the manager that a block has been added to the DAG
+func (m *Manager) NotifyBlockAddedToDAG(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error {
+	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyBlockAddedToDAG")
 	defer onEnd()
 
-	// Before converting the block and populating it, we check if any listeners are interested.
-	// This is done since most nodes do not use this event.
-	if !m.context.NotificationManager.HasBlockAddedListeners() {
-		return nil
+	err := m.NotifyVirtualChange(virtualChangeSet)
+	if err != nil {
+		return err
 	}
 
 	rpcBlock := appmessage.DomainBlockToRPCBlock(block)
-	err := m.context.PopulateBlockWithVerboseData(rpcBlock, block.Header, block, true)
+	err = m.context.PopulateBlockWithVerboseData(rpcBlock, block.Header, block, false)
 	if err != nil {
 		return err
 	}
 	blockAddedNotification := appmessage.NewBlockAddedNotificationMessage(rpcBlock)
-	err = m.context.NotificationManager.NotifyBlockAdded(blockAddedNotification)
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return m.context.NotificationManager.NotifyBlockAdded(blockAddedNotification)
 }
 
-// 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")
+// NotifyVirtualChange notifies the manager that the virtual block has been changed.
+func (m *Manager) NotifyVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error {
+	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyBlockAddedToDAG")
 	defer onEnd()
 
-	if m.context.Config.UTXOIndex && virtualChangeSet.VirtualUTXODiff != nil {
+	if m.context.Config.UTXOIndex {
 		err := m.notifyUTXOsChanged(virtualChangeSet)
 		if err != nil {
 			return err
 		}
 	}
 
-	err := m.notifyVirtualSelectedParentBlueScoreChanged(virtualChangeSet.VirtualSelectedParentBlueScore)
+	err := m.notifyVirtualSelectedParentBlueScoreChanged()
 	if err != nil {
 		return err
 	}
 
-	err = m.notifyVirtualDaaScoreChanged(virtualChangeSet.VirtualDAAScore)
+	err = m.notifyVirtualDaaScoreChanged()
 	if err != nil {
 		return err
 	}
 
-	if virtualChangeSet.VirtualSelectedParentChainChanges == nil ||
-		(len(virtualChangeSet.VirtualSelectedParentChainChanges.Added) == 0 &&
-			len(virtualChangeSet.VirtualSelectedParentChainChanges.Removed) == 0) {
-
-		return nil
-	}
-
 	err = m.notifyVirtualSelectedParentChainChanged(virtualChangeSet)
 	if err != nil {
 		return err
@@ -138,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 {
@@ -187,7 +138,6 @@ func (m *Manager) notifyUTXOsChanged(virtualChangeSet *externalapi.VirtualChange
 	if err != nil {
 		return err
 	}
-
 	return m.context.NotificationManager.NotifyUTXOsChanged(utxoIndexChanges)
 }
 
@@ -203,18 +153,33 @@ func (m *Manager) notifyPruningPointUTXOSetOverride() error {
 	return m.context.NotificationManager.NotifyPruningPointUTXOSetOverride()
 }
 
-func (m *Manager) notifyVirtualSelectedParentBlueScoreChanged(virtualSelectedParentBlueScore uint64) error {
+func (m *Manager) notifyVirtualSelectedParentBlueScoreChanged() error {
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualSelectedParentBlueScoreChanged")
 	defer onEnd()
 
-	notification := appmessage.NewVirtualSelectedParentBlueScoreChangedNotificationMessage(virtualSelectedParentBlueScore)
+	virtualSelectedParent, err := m.context.Domain.Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return err
+	}
+
+	blockInfo, err := m.context.Domain.Consensus().GetBlockInfo(virtualSelectedParent)
+	if err != nil {
+		return err
+	}
+
+	notification := appmessage.NewVirtualSelectedParentBlueScoreChangedNotificationMessage(blockInfo.BlueScore)
 	return m.context.NotificationManager.NotifyVirtualSelectedParentBlueScoreChanged(notification)
 }
 
-func (m *Manager) notifyVirtualDaaScoreChanged(virtualDAAScore uint64) error {
+func (m *Manager) notifyVirtualDaaScoreChanged() error {
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualDaaScoreChanged")
 	defer onEnd()
 
+	virtualDAAScore, err := m.context.Domain.Consensus().GetVirtualDAAScore()
+	if err != nil {
+		return err
+	}
+
 	notification := appmessage.NewVirtualDaaScoreChangedNotificationMessage(virtualDAAScore)
 	return m.context.NotificationManager.NotifyVirtualDaaScoreChanged(notification)
 }
@@ -223,25 +188,10 @@ func (m *Manager) notifyVirtualSelectedParentChainChanged(virtualChangeSet *exte
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualSelectedParentChainChanged")
 	defer onEnd()
 
-	listenersThatPropagateSelectedParentChanged :=
-		m.context.NotificationManager.AllListenersThatPropagateVirtualSelectedParentChainChanged()
-	if len(listenersThatPropagateSelectedParentChanged) > 0 {
-		// Generating acceptedTransactionIDs is a heavy operation, so we check if it's needed by any listener.
-		includeAcceptedTransactionIDs := false
-		for _, listener := range listenersThatPropagateSelectedParentChanged {
-			if listener.IncludeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications() {
-				includeAcceptedTransactionIDs = true
-				break
-			}
-		}
-
-		notification, err := m.context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
-			virtualChangeSet.VirtualSelectedParentChainChanges, includeAcceptedTransactionIDs)
-		if err != nil {
-			return err
-		}
-		return m.context.NotificationManager.NotifyVirtualSelectedParentChainChanged(notification)
+	notification, err := m.context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
+		virtualChangeSet.VirtualSelectedParentChainChanges)
+	if err != nil {
+		return err
 	}
-
-	return nil
+	return m.context.NotificationManager.NotifyVirtualSelectedParentChainChanged(notification)
 }

app/rpc/rpc.go

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

app/rpc/rpccontext/chain_changed.go

@@ -3,14 +3,12 @@ package rpccontext
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 )
 
 // ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage converts
 // VirtualSelectedParentChainChanges to VirtualSelectedParentChainChangedNotificationMessage
 func (ctx *Context) ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
-	selectedParentChainChanges *externalapi.SelectedChainPath, includeAcceptedTransactionIDs bool) (
-	*appmessage.VirtualSelectedParentChainChangedNotificationMessage, error) {
+	selectedParentChainChanges *externalapi.SelectedChainPath) (*appmessage.VirtualSelectedParentChainChangedNotificationMessage, error) {
 
 	removedChainBlockHashes := make([]string, len(selectedParentChainChanges.Removed))
 	for i, removed := range selectedParentChainChanges.Removed {
@@ -22,43 +20,5 @@ func (ctx *Context) ConvertVirtualSelectedParentChainChangesToChainChangedNotifi
 		addedChainBlocks[i] = added.String()
 	}
 
-	var acceptedTransactionIDs []*appmessage.AcceptedTransactionIDs
-	if includeAcceptedTransactionIDs {
-		var err error
-		acceptedTransactionIDs, err = ctx.getAndConvertAcceptedTransactionIDs(selectedParentChainChanges)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return appmessage.NewVirtualSelectedParentChainChangedNotificationMessage(
-		removedChainBlockHashes, addedChainBlocks, acceptedTransactionIDs), nil
-}
-
-func (ctx *Context) getAndConvertAcceptedTransactionIDs(selectedParentChainChanges *externalapi.SelectedChainPath) (
-	[]*appmessage.AcceptedTransactionIDs, error) {
-
-	acceptedTransactionIDs := make([]*appmessage.AcceptedTransactionIDs, len(selectedParentChainChanges.Added))
-
-	for i, addedChainBlock := range selectedParentChainChanges.Added {
-		blockAcceptanceData, err := ctx.Domain.Consensus().GetBlockAcceptanceData(addedChainBlock)
-		if err != nil {
-			return nil, err
-		}
-		acceptedTransactionIDs[i] = &appmessage.AcceptedTransactionIDs{
-			AcceptingBlockHash:     addedChainBlock.String(),
-			AcceptedTransactionIDs: nil,
-		}
-		for _, blockAcceptanceData := range blockAcceptanceData {
-			for _, transactionAcceptanceData := range blockAcceptanceData.TransactionAcceptanceData {
-				if transactionAcceptanceData.IsAccepted {
-					acceptedTransactionIDs[i].AcceptedTransactionIDs =
-						append(acceptedTransactionIDs[i].AcceptedTransactionIDs,
-							consensushashing.TransactionID(transactionAcceptanceData.Transaction).String())
-				}
-			}
-		}
-	}
-
-	return acceptedTransactionIDs, nil
+	return appmessage.NewVirtualSelectedParentChainChangedNotificationMessage(removedChainBlockHashes, addedChainBlocks), nil
 }

app/rpc/rpccontext/context.go

@@ -44,7 +44,7 @@ func NewContext(cfg *config.Config,
 		UTXOIndex:         utxoIndex,
 		ShutDownChan:      shutDownChan,
 	}
-	context.NotificationManager = NewNotificationManager(cfg.ActiveNetParams)
+	context.NotificationManager = NewNotificationManager()
 
 	return context
 }

app/rpc/rpccontext/notificationmanager.go

@@ -3,10 +3,6 @@ package rpccontext
 import (
 	"sync"
 
-	"github.com/kaspanet/kaspad/domain/dagconfig"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
-
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/domain/utxoindex"
 	routerpkg "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
@@ -17,7 +13,6 @@ import (
 type NotificationManager struct {
 	sync.RWMutex
 	listeners map[*routerpkg.Router]*NotificationListener
-	params    *dagconfig.Params
 }
 
 // UTXOsChangedNotificationAddress represents a kaspad address.
@@ -29,8 +24,6 @@ type UTXOsChangedNotificationAddress struct {
 
 // NotificationListener represents a registered RPC notification listener
 type NotificationListener struct {
-	params *dagconfig.Params
-
 	propagateBlockAddedNotifications                            bool
 	propagateVirtualSelectedParentChainChangedNotifications     bool
 	propagateFinalityConflictNotifications                      bool
@@ -39,16 +32,13 @@ type NotificationListener struct {
 	propagateVirtualSelectedParentBlueScoreChangedNotifications bool
 	propagateVirtualDaaScoreChangedNotifications                bool
 	propagatePruningPointUTXOSetOverrideNotifications           bool
-	propagateNewBlockTemplateNotifications                      bool
 
-	propagateUTXOsChangedNotificationAddresses                                    map[utxoindex.ScriptPublicKeyString]*UTXOsChangedNotificationAddress
-	includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications bool
+	propagateUTXOsChangedNotificationAddresses map[utxoindex.ScriptPublicKeyString]*UTXOsChangedNotificationAddress
 }
 
 // NewNotificationManager creates a new NotificationManager
-func NewNotificationManager(params *dagconfig.Params) *NotificationManager {
+func NewNotificationManager() *NotificationManager {
 	return &NotificationManager{
-		params:    params,
 		listeners: make(map[*routerpkg.Router]*NotificationListener),
 	}
 }
@@ -58,7 +48,7 @@ func (nm *NotificationManager) AddListener(router *routerpkg.Router) {
 	nm.Lock()
 	defer nm.Unlock()
 
-	listener := newNotificationListener(nm.params)
+	listener := newNotificationListener()
 	nm.listeners[router] = listener
 }
 
@@ -82,19 +72,6 @@ func (nm *NotificationManager) Listener(router *routerpkg.Router) (*Notification
 	return listener, nil
 }
 
-// HasBlockAddedListeners indicates if the notification manager has any listeners for `BlockAdded` events
-func (nm *NotificationManager) HasBlockAddedListeners() bool {
-	nm.RLock()
-	defer nm.RUnlock()
-
-	for _, listener := range nm.listeners {
-		if listener.propagateBlockAddedNotifications {
-			return true
-		}
-	}
-	return false
-}
-
 // NotifyBlockAdded notifies the notification manager that a block has been added to the DAG
 func (nm *NotificationManager) NotifyBlockAdded(notification *appmessage.BlockAddedNotificationMessage) error {
 	nm.RLock()
@@ -102,8 +79,10 @@ func (nm *NotificationManager) NotifyBlockAdded(notification *appmessage.BlockAd
 
 	for router, listener := range nm.listeners {
 		if listener.propagateBlockAddedNotifications {
-			err := router.OutgoingRoute().MaybeEnqueue(notification)
-			if err != nil {
+			err := router.OutgoingRoute().Enqueue(notification)
+			if errors.Is(err, routerpkg.ErrRouteClosed) {
+				log.Warnf("Couldn't send notification: %s", err)
+			} else if err != nil {
 				return err
 			}
 		}
@@ -112,27 +91,13 @@ func (nm *NotificationManager) NotifyBlockAdded(notification *appmessage.BlockAd
 }
 
 // NotifyVirtualSelectedParentChainChanged notifies the notification manager that the DAG's selected parent chain has changed
-func (nm *NotificationManager) NotifyVirtualSelectedParentChainChanged(
-	notification *appmessage.VirtualSelectedParentChainChangedNotificationMessage) error {
-
+func (nm *NotificationManager) NotifyVirtualSelectedParentChainChanged(notification *appmessage.VirtualSelectedParentChainChangedNotificationMessage) error {
 	nm.RLock()
 	defer nm.RUnlock()
 
-	notificationWithoutAcceptedTransactionIDs := &appmessage.VirtualSelectedParentChainChangedNotificationMessage{
-		RemovedChainBlockHashes: notification.RemovedChainBlockHashes,
-		AddedChainBlockHashes:   notification.AddedChainBlockHashes,
-	}
-
 	for router, listener := range nm.listeners {
 		if listener.propagateVirtualSelectedParentChainChangedNotifications {
-			var err error
-
-			if listener.includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications {
-				err = router.OutgoingRoute().MaybeEnqueue(notification)
-			} else {
-				err = router.OutgoingRoute().MaybeEnqueue(notificationWithoutAcceptedTransactionIDs)
-			}
-
+			err := router.OutgoingRoute().Enqueue(notification)
 			if err != nil {
 				return err
 			}
@@ -141,18 +106,6 @@ func (nm *NotificationManager) NotifyVirtualSelectedParentChainChanged(
 	return nil
 }
 
-// AllListenersThatPropagateVirtualSelectedParentChainChanged returns true if there's any listener that is
-// subscribed to VirtualSelectedParentChainChanged notifications.
-func (nm *NotificationManager) AllListenersThatPropagateVirtualSelectedParentChainChanged() []*NotificationListener {
-	var listenersThatPropagate []*NotificationListener
-	for _, listener := range nm.listeners {
-		if listener.propagateVirtualSelectedParentChainChangedNotifications {
-			listenersThatPropagate = append(listenersThatPropagate, listener)
-		}
-	}
-	return listenersThatPropagate
-}
-
 // NotifyFinalityConflict notifies the notification manager that there's a finality conflict in the DAG
 func (nm *NotificationManager) NotifyFinalityConflict(notification *appmessage.FinalityConflictNotificationMessage) error {
 	nm.RLock()
@@ -193,10 +146,7 @@ func (nm *NotificationManager) NotifyUTXOsChanged(utxoChanges *utxoindex.UTXOCha
 	for router, listener := range nm.listeners {
 		if listener.propagateUTXOsChangedNotifications {
 			// Filter utxoChanges and create a notification
-			notification, err := listener.convertUTXOChangesToUTXOsChangedNotification(utxoChanges)
-			if err != nil {
-				return err
-			}
+			notification := listener.convertUTXOChangesToUTXOsChangedNotification(utxoChanges)
 
 			// Don't send the notification if it's empty
 			if len(notification.Added) == 0 && len(notification.Removed) == 0 {
@@ -204,7 +154,7 @@ func (nm *NotificationManager) NotifyUTXOsChanged(utxoChanges *utxoindex.UTXOCha
 			}
 
 			// Enqueue the notification
-			err = router.OutgoingRoute().MaybeEnqueue(notification)
+			err := router.OutgoingRoute().Enqueue(notification)
 			if err != nil {
 				return err
 			}
@@ -223,7 +173,7 @@ func (nm *NotificationManager) NotifyVirtualSelectedParentBlueScoreChanged(
 
 	for router, listener := range nm.listeners {
 		if listener.propagateVirtualSelectedParentBlueScoreChangedNotifications {
-			err := router.OutgoingRoute().MaybeEnqueue(notification)
+			err := router.OutgoingRoute().Enqueue(notification)
 			if err != nil {
 				return err
 			}
@@ -242,25 +192,6 @@ func (nm *NotificationManager) NotifyVirtualDaaScoreChanged(
 
 	for router, listener := range nm.listeners {
 		if listener.propagateVirtualDaaScoreChangedNotifications {
-			err := router.OutgoingRoute().MaybeEnqueue(notification)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	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
@@ -287,27 +218,18 @@ func (nm *NotificationManager) NotifyPruningPointUTXOSetOverride() error {
 	return nil
 }
 
-func newNotificationListener(params *dagconfig.Params) *NotificationListener {
+func newNotificationListener() *NotificationListener {
 	return &NotificationListener{
-		params: params,
-
 		propagateBlockAddedNotifications:                            false,
 		propagateVirtualSelectedParentChainChangedNotifications:     false,
 		propagateFinalityConflictNotifications:                      false,
 		propagateFinalityConflictResolvedNotifications:              false,
 		propagateUTXOsChangedNotifications:                          false,
 		propagateVirtualSelectedParentBlueScoreChangedNotifications: false,
-		propagateNewBlockTemplateNotifications:                      false,
 		propagatePruningPointUTXOSetOverrideNotifications:           false,
 	}
 }
 
-// IncludeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications returns true if this listener
-// includes accepted transaction IDs in it's virtual-selected-parent-chain-changed notifications
-func (nl *NotificationListener) IncludeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications() bool {
-	return nl.includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications
-}
-
 // PropagateBlockAddedNotifications instructs the listener to send block added notifications
 // to the remote listener
 func (nl *NotificationListener) PropagateBlockAddedNotifications() {
@@ -316,9 +238,8 @@ func (nl *NotificationListener) PropagateBlockAddedNotifications() {
 
 // PropagateVirtualSelectedParentChainChangedNotifications instructs the listener to send chain changed notifications
 // to the remote listener
-func (nl *NotificationListener) PropagateVirtualSelectedParentChainChangedNotifications(includeAcceptedTransactionIDs bool) {
+func (nl *NotificationListener) PropagateVirtualSelectedParentChainChangedNotifications() {
 	nl.propagateVirtualSelectedParentChainChangedNotifications = true
-	nl.includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications = includeAcceptedTransactionIDs
 }
 
 // PropagateFinalityConflictNotifications instructs the listener to send finality conflict notifications
@@ -363,7 +284,7 @@ func (nl *NotificationListener) StopPropagatingUTXOsChangedNotifications(address
 }
 
 func (nl *NotificationListener) convertUTXOChangesToUTXOsChangedNotification(
-	utxoChanges *utxoindex.UTXOChanges) (*appmessage.UTXOsChangedNotificationMessage, error) {
+	utxoChanges *utxoindex.UTXOChanges) *appmessage.UTXOsChangedNotificationMessage {
 
 	// As an optimization, we iterate over the smaller set (O(n)) among the two below
 	// and check existence over the larger set (O(1))
@@ -384,7 +305,7 @@ func (nl *NotificationListener) convertUTXOChangesToUTXOsChangedNotification(
 				notification.Removed = append(notification.Removed, utxosByAddressesEntries...)
 			}
 		}
-	} else if addressesSize > 0 {
+	} else {
 		for _, listenerAddress := range nl.propagateUTXOsChangedNotificationAddresses {
 			listenerScriptPublicKeyString := listenerAddress.ScriptPublicKeyString
 			if addedPairs, ok := utxoChanges.Added[listenerScriptPublicKeyString]; ok {
@@ -396,46 +317,9 @@ func (nl *NotificationListener) convertUTXOChangesToUTXOsChangedNotification(
 				notification.Removed = append(notification.Removed, utxosByAddressesEntries...)
 			}
 		}
-	} else {
-		for scriptPublicKeyString, addedPairs := range utxoChanges.Added {
-			addressString, err := nl.scriptPubKeyStringToAddressString(scriptPublicKeyString)
-			if err != nil {
-				return nil, err
-			}
-
-			utxosByAddressesEntries := ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(addressString, addedPairs)
-			notification.Added = append(notification.Added, utxosByAddressesEntries...)
-		}
-		for scriptPublicKeyString, removedOutpoints := range utxoChanges.Removed {
-			addressString, err := nl.scriptPubKeyStringToAddressString(scriptPublicKeyString)
-			if err != nil {
-				return nil, err
-			}
-
-			utxosByAddressesEntries := convertUTXOOutpointsToUTXOsByAddressesEntries(addressString, removedOutpoints)
-			notification.Removed = append(notification.Removed, utxosByAddressesEntries...)
-		}
 	}
 
-	return notification, nil
-}
-
-func (nl *NotificationListener) scriptPubKeyStringToAddressString(scriptPublicKeyString utxoindex.ScriptPublicKeyString) (string, error) {
-	scriptPubKey := utxoindex.ConvertStringToScriptPublicKey(scriptPublicKeyString)
-
-	// ignore error because it is often returned when the script is of unknown type
-	scriptType, address, err := txscript.ExtractScriptPubKeyAddress(scriptPubKey, nl.params)
-	if err != nil {
-		return "", err
-	}
-
-	var addressString string
-	if scriptType == txscript.NonStandardTy {
-		addressString = ""
-	} else {
-		addressString = address.String()
-	}
-	return addressString, nil
+	return notification
 }
 
 // PropagateVirtualSelectedParentBlueScoreChangedNotifications instructs the listener to send
@@ -450,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_balance_by_address.go

@@ -22,7 +22,7 @@ func HandleGetBalanceByAddress(context *rpccontext.Context, _ *router.Router, re
 	balance, err := getBalanceByAddress(context, getBalanceByAddressRequest.Address)
 	if err != nil {
 		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
+		if !errors.As(err, rpcError) {
 			return nil, err
 		}
 		errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}

app/rpc/rpchandlers/get_balances_by_addresses.go

@@ -23,7 +23,7 @@ func HandleGetBalancesByAddresses(context *rpccontext.Context, _ *router.Router,
 
 		if err != nil {
 			rpcError := &appmessage.RPCError{}
-			if !errors.As(err, &rpcError) {
+			if !errors.As(err, rpcError) {
 				return nil, err
 			}
 			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}

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,20 +25,18 @@ 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, isNearlySynced, err := context.Domain.MiningManager().GetBlockTemplate(coinbaseData)
+	templateBlock, err := context.Domain.MiningManager().GetBlockTemplate(coinbaseData)
+	if err != nil {
+		return nil, err
+	}
+	rpcBlock := appmessage.DomainBlockToRPCBlock(templateBlock)
+
+	isSynced, err := context.ProtocolManager.ShouldMine()
 	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)
-
-	return appmessage.NewGetBlockTemplateResponseMessage(rpcBlock, context.ProtocolManager.Context().HasPeers() && isNearlySynced), nil
+	return appmessage.NewGetBlockTemplateResponseMessage(rpcBlock, isSynced), nil
 }

app/rpc/rpchandlers/get_blocks_test.go

@@ -23,10 +23,6 @@ type fakeDomain struct {
 	testapi.TestConsensus
 }
 
-func (d fakeDomain) ConsensusEventsChannel() chan externalapi.ConsensusEvent {
-	panic("implement me")
-}
-
 func (d fakeDomain) DeleteStagingConsensus() error {
 	panic("implement me")
 }
@@ -35,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/get_mempool_entries_by_addresses.go

@@ -1,97 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util"
-)
-
-// HandleGetMempoolEntriesByAddresses handles the respectively named RPC command
-func HandleGetMempoolEntriesByAddresses(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-
-	transactions := context.Domain.MiningManager().AllTransactions()
-	getMempoolEntriesByAddressesRequest := request.(*appmessage.GetMempoolEntriesByAddressesRequestMessage)
-	mempoolEntriesByAddresses := make([]*appmessage.MempoolEntryByAddress, 0)
-
-	for _, addressString := range getMempoolEntriesByAddressesRequest.Addresses {
-
-		_, err := util.DecodeAddress(addressString, context.Config.ActiveNetParams.Prefix)
-		if err != nil {
-			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("Could not decode address '%s': %s", addressString, err)
-			return errorMessage, nil
-		}
-
-		sending := make([]*appmessage.MempoolEntry, 0)
-		receiving := make([]*appmessage.MempoolEntry, 0)
-
-		for _, transaction := range transactions {
-
-			for i, input := range transaction.Inputs {
-				// TODO: Fix this
-				if input.UTXOEntry == nil {
-					log.Errorf("Couldn't find UTXO entry for input %d in mempool transaction %s. This is a bug and should be fixed.", i, consensushashing.TransactionID(transaction))
-					continue
-				}
-
-				_, transactionSendingAddress, err := txscript.ExtractScriptPubKeyAddress(
-					input.UTXOEntry.ScriptPublicKey(),
-					context.Config.ActiveNetParams)
-				if err != nil {
-					return nil, err
-				}
-				if addressString == transactionSendingAddress.String() {
-					rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
-					sending = append(
-						sending,
-						&appmessage.MempoolEntry{
-							Fee:         transaction.Fee,
-							Transaction: rpcTransaction,
-						},
-					)
-					break //one input is enough
-				}
-			}
-
-			for _, output := range transaction.Outputs {
-				_, transactionReceivingAddress, err := txscript.ExtractScriptPubKeyAddress(
-					output.ScriptPublicKey,
-					context.Config.ActiveNetParams,
-				)
-				if err != nil {
-					return nil, err
-				}
-				if addressString == transactionReceivingAddress.String() {
-					rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
-					receiving = append(
-						receiving,
-						&appmessage.MempoolEntry{
-							Fee:         transaction.Fee,
-							Transaction: rpcTransaction,
-						},
-					)
-					break //one output is enough
-				}
-			}
-
-			//Only append mempoolEntriesByAddress, if at least 1 mempoolEntry for the address is found.
-			//This mimics the behaviour of GetUtxosByAddresses RPC call.
-			if len(sending) > 0 || len(receiving) > 0 {
-				mempoolEntriesByAddresses = append(
-					mempoolEntriesByAddresses,
-					&appmessage.MempoolEntryByAddress{
-						Address:   addressString,
-						Sending:   sending,
-						Receiving: receiving,
-					},
-				)
-			}
-
-		}
-	}
-
-	return appmessage.NewGetMempoolEntriesByAddressesResponseMessage(mempoolEntriesByAddresses), nil
-}

app/rpc/rpchandlers/get_virtual_selected_parent_chain_from_block.go

@@ -26,14 +26,12 @@ func HandleGetVirtualSelectedParentChainFromBlock(context *rpccontext.Context, _
 		return response, nil
 	}
 
-	chainChangedNotification, err := context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
-		virtualSelectedParentChain, getVirtualSelectedParentChainFromBlockRequest.IncludeAcceptedTransactionIDs)
+	chainChangedNotification, err := context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(virtualSelectedParentChain)
 	if err != nil {
 		return nil, err
 	}
 
 	response := appmessage.NewGetVirtualSelectedParentChainFromBlockResponseMessage(
-		chainChangedNotification.RemovedChainBlockHashes, chainChangedNotification.AddedChainBlockHashes,
-		chainChangedNotification.AcceptedTransactionIDs)
+		chainChangedNotification.RemovedChainBlockHashes, chainChangedNotification.AddedChainBlockHashes)
 	return response, nil
 }

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/notify_virtual_selected_parent_chain_changed.go

@@ -7,17 +7,12 @@ import (
 )
 
 // HandleNotifyVirtualSelectedParentChainChanged handles the respectively named RPC command
-func HandleNotifyVirtualSelectedParentChainChanged(context *rpccontext.Context, router *router.Router,
-	request appmessage.Message) (appmessage.Message, error) {
-
-	notifyVirtualSelectedParentChainChangedRequest := request.(*appmessage.NotifyVirtualSelectedParentChainChangedRequestMessage)
-
+func HandleNotifyVirtualSelectedParentChainChanged(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
 	listener, err := context.NotificationManager.Listener(router)
 	if err != nil {
 		return nil, err
 	}
-	listener.PropagateVirtualSelectedParentChainChangedNotifications(
-		notifyVirtualSelectedParentChainChangedRequest.IncludeAcceptedTransactionIDs)
+	listener.PropagateVirtualSelectedParentChainChangedNotifications()
 
 	response := appmessage.NewNotifyVirtualSelectedParentChainChangedResponseMessage()
 	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"
@@ -15,14 +14,9 @@ import (
 func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
 	submitBlockRequest := request.(*appmessage.SubmitBlockRequestMessage)
 
-	var err error
-	isSynced := false
-	// The node is considered synced if it has peers and consensus state is nearly synced
-	if context.ProtocolManager.Context().HasPeers() {
-		isSynced, err = context.ProtocolManager.Context().IsNearlySynced()
-		if err != nil {
-			return nil, err
-		}
+	isSynced, err := context.ProtocolManager.ShouldMine()
+	if err != nil {
+		return nil, err
 	}
 
 	if !context.Config.AllowSubmitBlockWhenNotSynced && !isSynced {
@@ -64,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,75 +1,3 @@
-Kaspad v0.12.0 - 2022-04-14
-===========================
-Breaking changes:
-    Hard-fork at DAA score 14687583 (estimated to be on 28/04 16:38 UTC) which includes:
-    * Using separate depth than finality depth for merge set calculations (#2013)
-    * Not counting the header size as part of the block mass (#2013)
-    * Increasing block version to 1 (#2013)
-    * Removing the limit on amount of KAS that can be sent in one transaction (#2013)
-
-Bug fixes:
-* Making a workaround for the UTXO diff child bug (#2020)
-* Use cosigner index 0 for read only wallets (#2014)
-
-Non-breaking changes:
-* Adding a "sweep" command to `kaspawallet` (#2018)
-* Use `blue work` heuristic to skip irrelevant relay blocks
-* Kaspawallet daemon: Add Send and Sign commands (#2016)
-
-Kaspad v0.11.17 - 2022-04-06
-===========================
-* Decrement estimatedHeaderUpperBound from mempool's MaxBlockMass (#2009)
-
-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/commands.go

@@ -31,8 +31,6 @@ var commandTypes = []reflect.Type{
 
 	reflect.TypeOf(protowire.KaspadMessage_GetMempoolEntryRequest{}),
 	reflect.TypeOf(protowire.KaspadMessage_GetMempoolEntriesRequest{}),
-	reflect.TypeOf(protowire.KaspadMessage_GetMempoolEntriesByAddressesRequest{}),
-
 	reflect.TypeOf(protowire.KaspadMessage_SubmitTransactionRequest{}),
 
 	reflect.TypeOf(protowire.KaspadMessage_GetUtxosByAddressesRequest{}),

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/balance.go

@@ -3,12 +3,19 @@ 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/utils"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
 )
 
+func formatKas(amount uint64) string {
+	res := "                   "
+	if amount > 0 {
+		res = fmt.Sprintf("%19.8f", float64(amount)/constants.SompiPerKaspa)
+	}
+	return res
+}
+
 func balance(conf *balanceConfig) error {
 	daemonClient, tearDown, err := client.Connect(conf.DaemonAddress)
 	if err != nil {
@@ -32,12 +39,12 @@ func balance(conf *balanceConfig) error {
 		println("Address                                                                       Available             Pending")
 		println("-----------------------------------------------------------------------------------------------------------")
 		for _, addressBalance := range response.AddressBalances {
-			fmt.Printf("%s %s %s\n", addressBalance.Address, utils.FormatKas(addressBalance.Available), utils.FormatKas(addressBalance.Pending))
+			fmt.Printf("%s %s %s\n", addressBalance.Address, formatKas(addressBalance.Available), formatKas(addressBalance.Pending))
 		}
 		println("-----------------------------------------------------------------------------------------------------------")
 		print("                                                 ")
 	}
-	fmt.Printf("Total balance, KAS %s %s%s\n", utils.FormatKas(response.Available), utils.FormatKas(response.Pending), pendingSuffix)
+	fmt.Printf("Total balance, KAS %s %s%s\n", formatKas(response.Available), formatKas(response.Pending), pendingSuffix)
 
 	return nil
 }

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,36 +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
 	}
 
-	response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{Transactions: transactions})
+	response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{Transaction: transaction})
 	if err != nil {
 		return err
 	}
-	fmt.Println("Transactions were sent successfully")
-	fmt.Println("Transaction ID(s): ")
-	for _, txID := range response.TxIDs {
-		fmt.Printf("\t%s\n", txID)
-	}
+
+	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"
 )
@@ -13,7 +12,6 @@ const (
 	createSubCmd                    = "create"
 	balanceSubCmd                   = "balance"
 	sendSubCmd                      = "send"
-	sweepSubCmd                     = "sweep"
 	createUnsignedTransactionSubCmd = "create-unsigned-transaction"
 	signSubCmd                      = "sign"
 	broadcastSubCmd                 = "broadcast"
@@ -52,41 +50,33 @@ type balanceConfig struct {
 }
 
 type sendConfig 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"`
-	DaemonAddress string   `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
-	ToAddress     string   `long:"to-address" short:"t" description:"The public address to send Kaspa to" required:"true"`
-	FromAddresses []string `long:"from-address" short:"a" description:"Specific public address to send Kaspa from. Use multiple times to accept several addresses" required:"false"`
-	SendAmount    float64  `long:"send-amount" short:"v" description:"An amount to send in Kaspa (e.g. 1234.12345678)" required:"true"`
-	config.NetworkFlags
-}
-
-type sweepConfig struct {
-	PrivateKey    string `long:"private-key" short:"k" description:"Private key in hex format"`
-	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	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"`
+	DaemonAddress string  `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	ToAddress     string  `long:"to-address" short:"t" description:"The public address to send Kaspa to" required:"true"`
+	SendAmount    float64 `long:"send-amount" short:"v" description:"An amount to send in Kaspa (e.g. 1234.12345678)" required:"true"`
 	config.NetworkFlags
 }
 
 type createUnsignedTransactionConfig struct {
-	DaemonAddress string   `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
-	ToAddress     string   `long:"to-address" short:"t" description:"The public address to send Kaspa to" required:"true"`
-	FromAddresses []string `long:"from-address" short:"a" description:"Specific public address to send Kaspa from. Use multiple times to accept several addresses" required:"false"`
-	SendAmount    float64  `long:"send-amount" short:"v" description:"An amount to send in Kaspa (e.g. 1234.12345678)" required:"true"`
+	DaemonAddress string  `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	ToAddress     string  `long:"to-address" short:"t" description:"The public address to send Kaspa to" required:"true"`
+	SendAmount    float64 `long:"send-amount" short:"v" description:"An amount to send in Kaspa (e.g. 1234.12345678)" required:"true"`
 	config.NetworkFlags
 }
 
 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
 }
 
@@ -139,10 +129,6 @@ func parseCommandLine() (subCommand string, config interface{}) {
 	parser.AddCommand(sendSubCmd, "Sends a Kaspa transaction to a public address",
 		"Sends a Kaspa transaction to a public address", sendConf)
 
-	sweepConf := &sweepConfig{DaemonAddress: defaultListen}
-	parser.AddCommand(sweepSubCmd, "Sends all funds associated with the given private key, to a new address of the wallet",
-		"Sends all funds associated with the private key, to a given change address of the wallet", sweepConf)
-
 	createUnsignedTransactionConf := &createUnsignedTransactionConfig{DaemonAddress: defaultListen}
 	parser.AddCommand(createUnsignedTransactionSubCmd, "Create an unsigned Kaspa transaction",
 		"Create an unsigned Kaspa transaction", createUnsignedTransactionConf)
@@ -212,13 +198,6 @@ func parseCommandLine() (subCommand string, config interface{}) {
 			printErrorAndExit(err)
 		}
 		config = sendConf
-	case sweepSubCmd:
-		combineNetworkFlags(&sweepConf.NetworkFlags, &cfg.NetworkFlags)
-		err := sweepConf.ResolveNetwork(parser)
-		if err != nil {
-			printErrorAndExit(err)
-		}
-		config = sweepConf
 	case createUnsignedTransactionSubCmd:
 		combineNetworkFlags(&createUnsignedTransactionConf.NetworkFlags, &cfg.NetworkFlags)
 		err := createUnsignedTransactionConf.ResolveNetwork(parser)

cmd/kaspawallet/create.go

@@ -50,13 +50,9 @@ func create(conf *createConfig) error {
 		extendedPublicKeys = append(extendedPublicKeys, string(extendedPublicKey))
 	}
 
-	// For a read only wallet the cosigner index is 0
-	cosignerIndex := uint32(0)
-	if len(signerExtendedPublicKeys) > 0 {
-		cosignerIndex, err = libkaspawallet.MinimumCosignerIndex(signerExtendedPublicKeys, extendedPublicKeys)
-		if err != nil {
-			return err
-		}
+	cosignerIndex, err := libkaspawallet.MinimumCosignerIndex(signerExtendedPublicKeys, extendedPublicKeys)
+	if err != nil {
+		return err
 	}
 
 	file := keys.File{

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,8 +20,7 @@ func createUnsignedTransaction(conf *createUnsignedTransactionConfig) error {
 	defer cancel()
 
 	sendAmountSompi := uint64(conf.SendAmount * constants.SompiPerKaspa)
-	response, err := daemonClient.CreateUnsignedTransactions(ctx, &pb.CreateUnsignedTransactionsRequest{
-		From:    conf.FromAddresses,
+	response, err := daemonClient.CreateUnsignedTransaction(ctx, &pb.CreateUnsignedTransactionRequest{
 		Address: conf.ToAddress,
 		Amount:  sendAmountSompi,
 	})
@@ -30,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.proto

@@ -1,20 +1,14 @@
 syntax = "proto3";
 
 option go_package = "github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb";
-package kaspawalletd;
 
 service kaspawalletd {
   rpc GetBalance (GetBalanceRequest) returns (GetBalanceResponse) {}
-  rpc GetExternalSpendableUTXOs (GetExternalSpendableUTXOsRequest) returns (GetExternalSpendableUTXOsResponse) {}
-  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) {}
   rpc Broadcast (BroadcastRequest) returns (BroadcastResponse) {}
-  // Since SendRequest contains a password - this command should only be used on a trusted or secure connection
-  rpc Send(SendRequest) returns (SendResponse) {}
-  // Since SignRequest contains a password - this command should only be used on a trusted or secure connection
-  rpc Sign(SignRequest) returns (SignResponse) {}
 }
 
 message GetBalanceRequest {
@@ -27,19 +21,18 @@ message GetBalanceResponse {
 }
 
 message AddressBalances {
-  string address = 1;
-  uint64 available = 2;
-  uint64 pending = 3;
+    string address = 1;
+    uint64 available = 2;
+    uint64 pending = 3;
 }
 
-message CreateUnsignedTransactionsRequest {
+message CreateUnsignedTransactionRequest {
   string address = 1;
   uint64 amount = 2;
-  repeated string from = 3;
 }
 
-message CreateUnsignedTransactionsResponse {
-  repeated bytes unsignedTransactions = 1;
+message CreateUnsignedTransactionResponse {
+  bytes unsignedTransaction = 1;
 }
 
 message ShowAddressesRequest {
@@ -57,12 +50,11 @@ message NewAddressResponse {
 }
 
 message BroadcastRequest {
-        bool isDomain = 1;  
-        repeated bytes transactions = 2;
+  bytes transaction = 1;
 }
 
 message BroadcastResponse {
-  repeated string txIDs = 1;
+  string txID = 1;
 }
 
 message ShutdownRequest {
@@ -70,55 +62,3 @@ message ShutdownRequest {
 
 message ShutdownResponse {
 }
-
-message Outpoint {
-  string transactionId = 1;
-  uint32 index = 2;
-}
-
-message UtxosByAddressesEntry {
-  string address = 1;
-  Outpoint outpoint = 2;
-  UtxoEntry utxoEntry = 3;
-}
-
-message ScriptPublicKey {
-  uint32 version = 1;
-  string scriptPublicKey = 2;
-}
-
-message UtxoEntry {
-  uint64 amount = 1;
-  ScriptPublicKey scriptPublicKey = 2;
-  uint64 blockDaaScore = 3;
-  bool isCoinbase = 4;
-}
-
-message GetExternalSpendableUTXOsRequest{
-  string address = 1;
-}
-
-message GetExternalSpendableUTXOsResponse{
-  repeated UtxosByAddressesEntry Entries = 1;
-}
-// Since SendRequest contains a password - this command should only be used on a trusted or secure connection
-message SendRequest{
-  string toAddress = 1;
-  uint64 amount = 2;
-  string password = 3;
-  repeated string from = 4;
-}
-
-message SendResponse{
-  repeated string txIDs = 1;
-}
-
-// Since SignRequest contains a password - this command should only be used on a trusted or secure connection
-message SignRequest{
-  repeated bytes unsignedTransactions = 1;
-  string password = 2;
-}
-
-message SignResponse{
-  repeated bytes signedTransactions = 1;
-}

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

@@ -1,8 +1,4 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
-// versions:
-// - protoc-gen-go-grpc v1.2.0
-// - protoc             v3.17.2
-// source: kaspawalletd.proto
 
 package pb
 
@@ -23,16 +19,11 @@ 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)
-	GetExternalSpendableUTXOs(ctx context.Context, in *GetExternalSpendableUTXOsRequest, opts ...grpc.CallOption) (*GetExternalSpendableUTXOsResponse, 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)
 	Broadcast(ctx context.Context, in *BroadcastRequest, opts ...grpc.CallOption) (*BroadcastResponse, error)
-	// Since SendRequest contains a password - this command should only be used on a trusted or secure connection
-	Send(ctx context.Context, in *SendRequest, opts ...grpc.CallOption) (*SendResponse, error)
-	// Since SignRequest contains a password - this command should only be used on a trusted or secure connection
-	Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error)
 }
 
 type kaspawalletdClient struct {
@@ -45,25 +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) GetExternalSpendableUTXOs(ctx context.Context, in *GetExternalSpendableUTXOsRequest, opts ...grpc.CallOption) (*GetExternalSpendableUTXOsResponse, error) {
-	out := new(GetExternalSpendableUTXOsResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/GetExternalSpendableUTXOs", 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
 	}
@@ -72,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
 	}
@@ -81,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
 	}
@@ -90,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
 	}
@@ -99,25 +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...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *kaspawalletdClient) Send(ctx context.Context, in *SendRequest, opts ...grpc.CallOption) (*SendResponse, error) {
-	out := new(SendResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/Send", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *kaspawalletdClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) {
-	out := new(SignResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/Sign", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/kaspawalletd/Broadcast", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -129,16 +93,11 @@ func (c *kaspawalletdClient) Sign(ctx context.Context, in *SignRequest, opts ...
 // for forward compatibility
 type KaspawalletdServer interface {
 	GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error)
-	GetExternalSpendableUTXOs(context.Context, *GetExternalSpendableUTXOsRequest) (*GetExternalSpendableUTXOsResponse, 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)
 	Broadcast(context.Context, *BroadcastRequest) (*BroadcastResponse, error)
-	// Since SendRequest contains a password - this command should only be used on a trusted or secure connection
-	Send(context.Context, *SendRequest) (*SendResponse, error)
-	// Since SignRequest contains a password - this command should only be used on a trusted or secure connection
-	Sign(context.Context, *SignRequest) (*SignResponse, error)
 	mustEmbedUnimplementedKaspawalletdServer()
 }
 
@@ -149,11 +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) GetExternalSpendableUTXOs(context.Context, *GetExternalSpendableUTXOsRequest) (*GetExternalSpendableUTXOsResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetExternalSpendableUTXOs 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")
@@ -167,12 +123,6 @@ func (UnimplementedKaspawalletdServer) Shutdown(context.Context, *ShutdownReques
 func (UnimplementedKaspawalletdServer) Broadcast(context.Context, *BroadcastRequest) (*BroadcastResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Broadcast not implemented")
 }
-func (UnimplementedKaspawalletdServer) Send(context.Context, *SendRequest) (*SendResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Send not implemented")
-}
-func (UnimplementedKaspawalletdServer) Sign(context.Context, *SignRequest) (*SignResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Sign not implemented")
-}
 func (UnimplementedKaspawalletdServer) mustEmbedUnimplementedKaspawalletdServer() {}
 
 // UnsafeKaspawalletdServer may be embedded to opt out of forward compatibility for this service.
@@ -196,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))
@@ -204,38 +154,20 @@ func _Kaspawalletd_GetBalance_Handler(srv interface{}, ctx context.Context, dec
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Kaspawalletd_GetExternalSpendableUTXOs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetExternalSpendableUTXOsRequest)
+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).GetExternalSpendableUTXOs(ctx, in)
+		return srv.(KaspawalletdServer).CreateUnsignedTransaction(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/kaspawalletd.kaspawalletd/GetExternalSpendableUTXOs",
+		FullMethod: "/kaspawalletd/CreateUnsignedTransaction",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(KaspawalletdServer).GetExternalSpendableUTXOs(ctx, req.(*GetExternalSpendableUTXOsRequest))
-	}
-	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)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(KaspawalletdServer).CreateUnsignedTransactions(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/kaspawalletd.kaspawalletd/CreateUnsignedTransactions",
-	}
-	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)
 }
@@ -250,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))
@@ -268,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))
@@ -286,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))
@@ -304,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))
@@ -312,47 +244,11 @@ func _Kaspawalletd_Broadcast_Handler(srv interface{}, ctx context.Context, dec f
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Kaspawalletd_Send_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(SendRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(KaspawalletdServer).Send(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/kaspawalletd.kaspawalletd/Send",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(KaspawalletdServer).Send(ctx, req.(*SendRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Kaspawalletd_Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(SignRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(KaspawalletdServer).Sign(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/kaspawalletd.kaspawalletd/Sign",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(KaspawalletdServer).Sign(ctx, req.(*SignRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 // Kaspawalletd_ServiceDesc is the grpc.ServiceDesc for Kaspawalletd service.
 // 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{
 		{
@@ -360,12 +256,8 @@ var Kaspawalletd_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _Kaspawalletd_GetBalance_Handler,
 		},
 		{
-			MethodName: "GetExternalSpendableUTXOs",
-			Handler:    _Kaspawalletd_GetExternalSpendableUTXOs_Handler,
-		},
-		{
-			MethodName: "CreateUnsignedTransactions",
-			Handler:    _Kaspawalletd_CreateUnsignedTransactions_Handler,
+			MethodName: "CreateUnsignedTransaction",
+			Handler:    _Kaspawalletd_CreateUnsignedTransaction_Handler,
 		},
 		{
 			MethodName: "ShowAddresses",
@@ -383,14 +275,6 @@ var Kaspawalletd_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "Broadcast",
 			Handler:    _Kaspawalletd_Broadcast_Handler,
 		},
-		{
-			MethodName: "Send",
-			Handler:    _Kaspawalletd_Send_Handler,
-		},
-		{
-			MethodName: "Sign",
-			Handler:    _Kaspawalletd_Sign_Handler,
-		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "kaspawalletd.proto",

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/broadcast.go

@@ -2,64 +2,27 @@ package server
 
 import (
 	"context"
+
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
 	"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/infrastructure/network/rpcclient"
 	"github.com/pkg/errors"
-	"time"
 )
 
 func (s *server) Broadcast(_ context.Context, request *pb.BroadcastRequest) (*pb.BroadcastResponse, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	txIDs, err := s.broadcast(request.Transactions, request.IsDomain)
+	tx, err := libkaspawallet.ExtractTransaction(request.Transaction, s.keysFile.ECDSA)
 	if err != nil {
 		return nil, err
 	}
 
-	return &pb.BroadcastResponse{TxIDs: txIDs}, nil
-}
-
-func (s *server) broadcast(transactions [][]byte, isDomain bool) ([]string, error) {
-
-	txIDs := make([]string, len(transactions))
-	var tx *externalapi.DomainTransaction
-	var err error
-
-	for i, transaction := range transactions {
-
-		if isDomain {
-			tx, err = serialization.DeserializeDomainTransaction(transaction)
-			if err != nil {
-				return nil, err
-			}
-		} else if !isDomain { //default in proto3 is false
-			tx, err = libkaspawallet.ExtractTransaction(transaction, s.keysFile.ECDSA)
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		txIDs[i], err = sendTransaction(s.rpcClient, tx)
-		if err != nil {
-			return nil, err
-		}
-
-		for _, input := range tx.Inputs {
-			s.usedOutpoints[input.PreviousOutpoint] = time.Now()
-		}
-	}
-
-	err = s.refreshUTXOs()
+	txID, err := sendTransaction(s.rpcClient, tx)
 	if err != nil {
 		return nil, err
 	}
 
-	return txIDs, nil
+	return &pb.BroadcastResponse{TxID: txID}, nil
 }
 
 func sendTransaction(client *rpcclient.RPCClient, tx *externalapi.DomainTransaction) (string, error) {

cmd/kaspawallet/daemon/server/create_unsigned_transaction.go

@@ -2,33 +2,18 @@ package server
 
 import (
 	"context"
-	"fmt"
+
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/pkg/errors"
-	"golang.org/x/exp/slices"
-	"time"
 )
 
-// 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()
 
-	unsignedTransactions, err := s.createUnsignedTransactions(request.Address, request.Amount, request.From)
-	if err != nil {
-		return nil, err
-	}
-
-	return &pb.CreateUnsignedTransactionsResponse{UnsignedTransactions: unsignedTransactions}, nil
-}
-
-func (s *server) createUnsignedTransactions(address string, amount uint64, fromAddressesString []string) ([][]byte, error) {
 	if !s.isSynced() {
 		return nil, errors.New("server is not synced")
 	}
@@ -38,55 +23,40 @@ func (s *server) createUnsignedTransactions(address string, amount uint64, fromA
 		return nil, err
 	}
 
-	toAddress, err := util.DecodeAddress(address, s.params.Prefix)
+	toAddress, err := util.DecodeAddress(request.Address, s.params.Prefix)
 	if err != nil {
 		return nil, err
 	}
 
-	var fromAddresses []*walletAddress
-	for _, from := range fromAddressesString {
-		fromAddress, exists := s.addressSet[from]
-		if !exists {
-			return nil, fmt.Errorf("Specified from address %s does not exists", from)
-		}
-		fromAddresses = append(fromAddresses, fromAddress)
-	}
-
-	selectedUTXOs, changeSompi, err := s.selectUTXOs(amount, feePerInput, fromAddresses)
+	// 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
 	}
 
-	payments := []*libkaspawallet.Payment{{
-		Address: toAddress,
-		Amount:  amount,
-	}}
-	if changeSompi > 0 {
-		payments = append(payments, &libkaspawallet.Payment{
-			Address: changeAddress,
-			Amount:  changeSompi,
-		})
-	}
 	unsignedTransaction, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
 		s.keysFile.MinimumSignatures,
-		payments, selectedUTXOs)
+		[]*libkaspawallet.Payment{{
+			Address: toAddress,
+			Amount:  request.Amount,
+		}, {
+			Address: changeAddress,
+			Amount:  changeSompi,
+		}}, selectedUTXOs)
 	if err != nil {
 		return nil, err
 	}
 
-	unsignedTransactions, err := s.maybeAutoCompoundTransaction(unsignedTransaction, toAddress, changeAddress, changeWalletAddress)
-	if err != nil {
-		return nil, err
-	}
-	return unsignedTransactions, nil
+	return &pb.CreateUnsignedTransactionResponse{UnsignedTransaction: unsignedTransaction}, nil
 }
 
-func (s *server) selectUTXOs(spendAmount uint64, feePerInput uint64, fromAddresses []*walletAddress) (
+func (s *server) selectUTXOs(spendAmount uint64, feePerInput uint64) (
 	selectedUTXOs []*libkaspawallet.UTXO, changeSompi uint64, err error) {
 
 	selectedUTXOs = []*libkaspawallet.UTXO{}
@@ -98,19 +68,10 @@ func (s *server) selectUTXOs(spendAmount uint64, feePerInput uint64, fromAddress
 	}
 
 	for _, utxo := range s.utxosSortedByAmount {
-		if (fromAddresses != nil && !slices.Contains(fromAddresses, utxo.address)) ||
-			!isUTXOSpendable(utxo, dagInfo.VirtualDAAScore, s.params.BlockCoinbaseMaturity) {
+		if !isUTXOSpendable(utxo, dagInfo.VirtualDAAScore, s.params.BlockCoinbaseMaturity) {
 			continue
 		}
 
-		if broadcastTime, ok := s.usedOutpoints[*utxo.Outpoint]; ok {
-			if time.Since(broadcastTime) > time.Minute {
-				delete(s.usedOutpoints, *utxo.Outpoint)
-			} else {
-				continue
-			}
-		}
-
 		selectedUTXOs = append(selectedUTXOs, &libkaspawallet.UTXO{
 			Outpoint:       utxo.Outpoint,
 			UTXOEntry:      utxo.UTXOEntry,

cmd/kaspawallet/daemon/server/external_spendable_utxos.go

@@ -1,63 +0,0 @@
-package server
-
-import (
-	"context"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
-	"github.com/kaspanet/kaspad/util"
-)
-
-func (s *server) GetExternalSpendableUTXOs(_ context.Context, request *pb.GetExternalSpendableUTXOsRequest) (*pb.GetExternalSpendableUTXOsResponse, error) {
-	s.lock.RLock()
-	defer s.lock.RUnlock()
-
-	_, err := util.DecodeAddress(request.Address, s.params.Prefix)
-	if err != nil {
-		return nil, err
-	}
-	externalUTXOs, err := s.rpcClient.GetUTXOsByAddresses([]string{request.Address})
-	if err != nil {
-		return nil, err
-	}
-	selectedUTXOs, err := s.selectExternalSpendableUTXOs(externalUTXOs, request.Address)
-	if err != nil {
-		return nil, err
-	}
-	return &pb.GetExternalSpendableUTXOsResponse{
-		Entries: selectedUTXOs,
-	}, nil
-}
-
-func (s *server) selectExternalSpendableUTXOs(externalUTXOs *appmessage.GetUTXOsByAddressesResponseMessage, address string) ([]*pb.UtxosByAddressesEntry, error) {
-
-	dagInfo, err := s.rpcClient.GetBlockDAGInfo()
-	if err != nil {
-		return nil, err
-	}
-
-	daaScore := dagInfo.VirtualDAAScore
-	maturity := s.params.BlockCoinbaseMaturity
-
-	//we do not make because we do not know size, because of unspendable utxos
-	var selectedExternalUtxos []*pb.UtxosByAddressesEntry
-
-	for _, entry := range externalUTXOs.Entries {
-		if !isExternalUTXOSpendable(entry, daaScore, maturity) {
-			continue
-		}
-		selectedExternalUtxos = append(selectedExternalUtxos, libkaspawallet.AppMessageUTXOToKaspawalletdUTXO(entry))
-	}
-
-	return selectedExternalUtxos, nil
-}
-
-func isExternalUTXOSpendable(entry *appmessage.UTXOsByAddressesEntry, virtualDAAScore uint64, coinbaseMaturity uint64) bool {
-	if !entry.UTXOEntry.IsCoinbase {
-		return true
-	} else if entry.UTXOEntry.Amount <= feePerInput {
-		return false
-	}
-	return entry.UTXOEntry.BlockDAAScore+coinbaseMaturity < virtualDAAScore
-}

cmd/kaspawallet/daemon/server/send.go

@@ -1,25 +0,0 @@
-package server
-
-import (
-	"context"
-
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-)
-
-func (s *server) Send(_ context.Context, request *pb.SendRequest) (*pb.SendResponse, error) {
-	unsignedTransactions, err := s.createUnsignedTransactions(request.ToAddress, request.Amount, request.From)
-	if err != nil {
-		return nil, err
-	}
-	signedTransactions, err := s.signTransactions(unsignedTransactions, request.Password)
-	if err != nil {
-		return nil, err
-	}
-
-	txIDs, err := s.broadcast(signedTransactions, false)
-	if err != nil {
-		return nil, err
-	}
-
-	return &pb.SendResponse{TxIDs: txIDs}, nil
-}

cmd/kaspawallet/daemon/server/server.go

@@ -2,14 +2,11 @@ package server
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"net"
 	"os"
 	"sync"
 	"time"
 
-	"github.com/kaspanet/kaspad/util/txmass"
-
 	"github.com/kaspanet/kaspad/util/profiling"
 
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
@@ -35,8 +32,6 @@ type server struct {
 	keysFile            *keys.File
 	shutdown            chan struct{}
 	addressSet          walletAddressSet
-	txMassCalculator    *txmass.Calculator
-	usedOutpoints       map[externalapi.DomainOutpoint]time.Time
 }
 
 // Start starts the kaspawalletd server
@@ -74,8 +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),
-		usedOutpoints:       map[externalapi.DomainOutpoint]time.Time{},
 	}
 
 	spawn("serverInstance.sync", func() {

cmd/kaspawallet/daemon/server/sign.go

@@ -1,36 +0,0 @@
-package server
-
-import (
-	"context"
-
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
-
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-)
-
-func (s *server) Sign(_ context.Context, request *pb.SignRequest) (*pb.SignResponse, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	signedTransactions, err := s.signTransactions(request.UnsignedTransactions, request.Password)
-	if err != nil {
-		return nil, err
-	}
-	return &pb.SignResponse{SignedTransactions: signedTransactions}, nil
-}
-
-func (s *server) signTransactions(unsignedTransactions [][]byte, password string) ([][]byte, error) {
-	mnemonics, err := s.keysFile.DecryptMnemonics(password)
-	if err != nil {
-		return nil, err
-	}
-	signedTransactions := make([][]byte, len(unsignedTransactions))
-	for i, unsignedTransaction := range unsignedTransactions {
-		signedTransaction, err := libkaspawallet.Sign(s.params, mnemonics, unsignedTransaction, s.keysFile.ECDSA)
-		if err != nil {
-			return nil, err
-		}
-		signedTransactions[i] = signedTransaction
-	}
-	return signedTransactions, nil
-}

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

@@ -26,28 +26,19 @@ func (s *server) sync() error {
 	ticker := time.NewTicker(time.Second)
 	defer ticker.Stop()
 
-	err := s.collectRecentAddresses()
-	if err != nil {
-		return err
-	}
-
-	err = s.refreshExistingUTXOsWithLock()
-	if err != nil {
-		return err
-	}
-
 	for range ticker.C {
+		err := s.collectRecentAddresses()
+		if err != nil {
+			return err
+		}
+
 		err = s.collectFarAddresses()
 		if err != nil {
 			return err
 		}
 
-		err = s.collectRecentAddresses()
-		if err != nil {
-			return err
-		}
-
 		err = s.refreshExistingUTXOsWithLock()
+
 		if err != nil {
 			return err
 		}
@@ -56,8 +47,7 @@ func (s *server) sync() error {
 	return nil
 }
 
-const numIndexesToQueryForFarAddresses = 100
-const numIndexesToQueryForRecentAddresses = 1000
+const numIndexesToQuery = 100
 
 // addressesToQuery scans the addresses in the given range. Because
 // each cosigner in a multisig has its own unique path for generating
@@ -85,17 +75,17 @@ func (s *server) addressesToQuery(start, end uint32) (walletAddressSet, error) {
 	return addresses, nil
 }
 
-// collectFarAddresses collects numIndexesToQueryForFarAddresses addresses
+// collectFarAddresses collects numIndexesToQuery addresses
 // from the last point it stopped in the previous call.
 func (s *server) collectFarAddresses() error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
-	err := s.collectAddresses(s.nextSyncStartIndex, s.nextSyncStartIndex+numIndexesToQueryForFarAddresses)
+	err := s.collectAddresses(s.nextSyncStartIndex, s.nextSyncStartIndex+numIndexesToQuery)
 	if err != nil {
 		return err
 	}
 
-	s.nextSyncStartIndex += numIndexesToQueryForFarAddresses
+	s.nextSyncStartIndex += numIndexesToQuery
 	return nil
 }
 
@@ -112,26 +102,18 @@ func (s *server) maxUsedIndex() uint32 {
 }
 
 // collectRecentAddresses collects addresses from used addresses until
-// the address with the index of the last used address + numIndexesToQueryForRecentAddresses.
-// collectRecentAddresses scans addresses in batches of numIndexesToQueryForRecentAddresses,
+// the address with the index of the last used address + 1000.
+// collectRecentAddresses scans addresses in batches of numIndexesToQuery,
 // and releases the lock between scans.
 func (s *server) collectRecentAddresses() error {
-	index := uint32(0)
-	maxUsedIndex := uint32(0)
-	for ; index < maxUsedIndex+numIndexesToQueryForRecentAddresses; index += numIndexesToQueryForRecentAddresses {
-		err := s.collectAddressesWithLock(index, index+numIndexesToQueryForRecentAddresses)
+	maxUsedIndex := s.maxUsedIndex()
+	for i := uint32(0); i < maxUsedIndex+1000; i += numIndexesToQuery {
+		err := s.collectAddressesWithLock(i, i+numIndexesToQuery)
 		if err != nil {
 			return err
 		}
-		maxUsedIndex = s.maxUsedIndex()
 	}
 
-	s.lock.Lock()
-	if index > s.nextSyncStartIndex {
-		s.nextSyncStartIndex = index
-	}
-	s.lock.Unlock()
-
 	return nil
 }
 
@@ -177,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 {
@@ -207,23 +193,10 @@ func (s *server) refreshExistingUTXOsWithLock() error {
 }
 
 // updateUTXOSet clears the current UTXO set, and re-fills it with the given entries
-func (s *server) updateUTXOSet(entries []*appmessage.UTXOsByAddressesEntry, mempoolEntries []*appmessage.MempoolEntryByAddress) error {
-	utxos := make([]*walletUTXO, 0, len(entries))
-
-	exclude := make(map[appmessage.RPCOutpoint]struct{})
-	for _, entriesByAddress := range mempoolEntries {
-		for _, entry := range entriesByAddress.Sending {
-			for _, input := range entry.Transaction.Inputs {
-				exclude[*input.PreviousOutpoint] = struct{}{}
-			}
-		}
-	}
-
-	for _, entry := range entries {
-		if _, ok := exclude[*entry.Outpoint]; ok {
-			continue
-		}
+func (s *server) updateUTXOSet(entries []*appmessage.UTXOsByAddressesEntry) error {
+	utxos := make([]*walletUTXO, len(entries))
 
+	for i, entry := range entries {
 		outpoint, err := appmessage.RPCOutpointToDomainOutpoint(entry.Outpoint)
 		if err != nil {
 			return err
@@ -238,11 +211,11 @@ func (s *server) updateUTXOSet(entries []*appmessage.UTXOsByAddressesEntry, memp
 		if !ok {
 			return errors.Errorf("Got result from address %s even though it wasn't requested", entry.Address)
 		}
-		utxos = append(utxos, &walletUTXO{
+		utxos[i] = &walletUTXO{
 			Outpoint:  outpoint,
 			UTXOEntry: utxoEntry,
 			address:   address,
-		})
+		}
 	}
 
 	sort.Slice(utxos, func(i, j int) bool { return utxos[i].UTXOEntry.Amount() > utxos[j].UTXOEntry.Amount() })
@@ -253,22 +226,12 @@ func (s *server) updateUTXOSet(entries []*appmessage.UTXOsByAddressesEntry, memp
 }
 
 func (s *server) refreshUTXOs() error {
-	// It's important to check the mempool before calling `GetUTXOsByAddresses`:
-	// If we would do it the other way around an output can be spent in the mempool
-	// and not in consensus, and between the calls its spending transaction will be
-	// added to consensus and removed from the mempool, so `getUTXOsByAddressesResponse`
-	// will include an obsolete output.
-	mempoolEntriesByAddresses, err := s.rpcClient.GetMempoolEntriesByAddresses(s.addressSet.strings())
-	if err != nil {
-		return err
-	}
-
 	getUTXOsByAddressesResponse, err := s.rpcClient.GetUTXOsByAddresses(s.addressSet.strings())
 	if err != nil {
 		return err
 	}
 
-	return s.updateUTXOSet(getUTXOsByAddressesResponse.Entries, mempoolEntriesByAddresses.Entries)
+	return s.updateUTXOSet(getUTXOsByAddressesResponse.Entries)
 }
 
 func (s *server) isSynced() bool {

cmd/kaspawallet/dump_unencrypted_data.go

@@ -3,11 +3,10 @@ package main
 import (
 	"bufio"
 	"fmt"
-	"os"
-
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/keys"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/utils"
+	"os"
 
 	"github.com/pkg/errors"
 )
@@ -25,9 +24,6 @@ func dumpUnencryptedData(conf *dumpUnencryptedDataConfig) error {
 		return err
 	}
 
-	if len(conf.Password) == 0 {
-		conf.Password = keys.GetPassword("Password:")
-	}
 	mnemonics, err := keysFile.DecryptMnemonics(conf.Password)
 	if err != nil {
 		return err

cmd/kaspawallet/keys/create.go

@@ -5,13 +5,12 @@ import (
 	"crypto/rand"
 	"crypto/subtle"
 	"fmt"
-	"os"
-
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/utils"
 	"github.com/kaspanet/kaspad/domain/dagconfig"
 	"github.com/pkg/errors"
 	"github.com/tyler-smith/go-bip39"
+	"os"
 )
 
 // CreateMnemonics generates `numKeys` number of mnemonics.
@@ -53,8 +52,8 @@ func encryptedMnemonicExtendedPublicKeyPairs(params *dagconfig.Params, mnemonics
 	password := []byte(cmdLinePassword)
 	if len(password) == 0 {
 
-		password = []byte(GetPassword("Enter password for the key file:"))
-		confirmPassword := []byte(GetPassword("Confirm password:"))
+		password = getPassword("Enter password for the key file:")
+		confirmPassword := getPassword("Confirm password:")
 
 		if subtle.ConstantTimeCompare(password, confirmPassword) != 1 {
 			return nil, nil, errors.New("Passwords are not identical")

cmd/kaspawallet/keys/get_password.go

@@ -2,15 +2,14 @@ package keys
 
 import (
 	"fmt"
+	"golang.org/x/term"
 	"os"
 	"os/signal"
 	"syscall"
-
-	"golang.org/x/term"
 )
 
-// GetPassword was adapted from https://gist.github.com/jlinoff/e8e26b4ffa38d379c7f1891fd174a6d0#file-getpassword2-go
-func GetPassword(prompt string) string {
+// getPassword was adapted from https://gist.github.com/jlinoff/e8e26b4ffa38d379c7f1891fd174a6d0#file-getpassword2-go
+func getPassword(prompt string) []byte {
 	// Get the initial state of the terminal.
 	initialTermState, e1 := term.GetState(int(syscall.Stdin))
 	if e1 != nil {
@@ -38,5 +37,5 @@ func GetPassword(prompt string) string {
 	// Stop looking for ^C on the channel.
 	signal.Stop(c)
 
-	return string(p)
+	return p
 }

cmd/kaspawallet/keys/keys.go

@@ -206,13 +206,16 @@ func (d *File) LastUsedInternalIndex() uint32 {
 
 // DecryptMnemonics asks the user to enter the password for the private keys and
 // returns the decrypted private keys.
-func (d *File) DecryptMnemonics(password string) ([]string, error) {
-	passwordBytes := []byte(password)
+func (d *File) DecryptMnemonics(cmdLinePassword string) ([]string, error) {
+	password := []byte(cmdLinePassword)
+	if len(password) == 0 {
+		password = getPassword("Password:")
+	}
 
 	var numThreads uint8
 	if len(d.EncryptedMnemonics) > 0 {
 		var err error
-		numThreads, err = d.numThreads(passwordBytes)
+		numThreads, err = d.numThreads(password)
 		if err != nil {
 			return nil, err
 		}
@@ -221,7 +224,7 @@ func (d *File) DecryptMnemonics(password string) ([]string, error) {
 	privateKeys := make([]string, len(d.EncryptedMnemonics))
 	for i, encryptedPrivateKey := range d.EncryptedMnemonics {
 		var err error
-		privateKeys[i], err = decryptMnemonic(numThreads, encryptedPrivateKey, passwordBytes)
+		privateKeys[i], err = decryptMnemonic(numThreads, encryptedPrivateKey, password)
 		if err != nil {
 			return nil, err
 		}