Update changelog to v0.12.2 (#2091)

* RPC: include orphans into mempool entries

* no need for + 1

* give request option to choose mempool pool(s)

* add to wallet, fix bg

* use orphanpool rpc to test for orphans

* fix fmt

* fix crash when quering orphan pool in get_mempool_entries

* pass the tests, fix fromAppMessage bug

* Update config_test.go

don't think this is needed

* needed for tests to pass

* inverse to transactionpoolfilter, cut down code to two ifs.

* fmt

* update test to true false, forgot one includetransactionpool renaming

* update and simplyfiy get_mempool_entry handler

* comment outdated

* i think we usually use make instead of var.

* Fix some leftovers of includeTransactionPool

Co-authored-by: Ori Newman <orinewman1@gmail.com>

app/appmessage/message.go

@@ -159,6 +159,10 @@ const (
 	CmdNotifyNewBlockTemplateRequestMessage
 	CmdNotifyNewBlockTemplateResponseMessage
 	CmdNewBlockTemplateNotificationMessage
+	CmdGetMempoolEntriesByAddressesRequestMessage
+	CmdGetMempoolEntriesByAddressesResponseMessage
+	CmdGetCoinSupplyRequestMessage
+	CmdGetCoinSupplyResponseMessage
 )
 
 // ProtocolMessageCommandToString maps all MessageCommands to their string representation
@@ -292,6 +296,10 @@ var RPCMessageCommandToString = map[MessageCommand]string{
 	CmdNotifyNewBlockTemplateRequestMessage:                       "NotifyNewBlockTemplateRequest",
 	CmdNotifyNewBlockTemplateResponseMessage:                      "NotifyNewBlockTemplateResponse",
 	CmdNewBlockTemplateNotificationMessage:                        "NewBlockTemplateNotification",
+	CmdGetMempoolEntriesByAddressesRequestMessage:                 "GetMempoolEntriesByAddressesRequest",
+	CmdGetMempoolEntriesByAddressesResponseMessage:                "GetMempoolEntriesByAddressesResponse",
+	CmdGetCoinSupplyRequestMessage:                                "GetCoinSupplyRequest",
+	CmdGetCoinSupplyResponseMessage:                               "GetCoinSupplyResponse",
 }
 
 // Message is an interface that describes a kaspa message. A type that

app/appmessage/rpc_get_coin_supply.go

@@ -0,0 +1,40 @@
+package appmessage
+
+// GetCoinSupplyRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetCoinSupplyRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetCoinSupplyRequestMessage) Command() MessageCommand {
+	return CmdGetCoinSupplyRequestMessage
+}
+
+// NewGetCoinSupplyRequestMessage returns a instance of the message
+func NewGetCoinSupplyRequestMessage() *GetCoinSupplyRequestMessage {
+	return &GetCoinSupplyRequestMessage{}
+}
+
+// GetCoinSupplyResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetCoinSupplyResponseMessage struct {
+	baseMessage
+	MaxSompi         uint64
+	CirculatingSompi uint64
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetCoinSupplyResponseMessage) Command() MessageCommand {
+	return CmdGetCoinSupplyResponseMessage
+}
+
+// NewGetCoinSupplyResponseMessage returns a instance of the message
+func NewGetCoinSupplyResponseMessage(maxSompi uint64, circulatingSompi uint64) *GetCoinSupplyResponseMessage {
+	return &GetCoinSupplyResponseMessage{
+		MaxSompi:         maxSompi,
+		CirculatingSompi: circulatingSompi,
+	}
+}

app/appmessage/rpc_get_info.go

@@ -23,6 +23,8 @@ type GetInfoResponseMessage struct {
 	P2PID         string
 	MempoolSize   uint64
 	ServerVersion string
+	IsUtxoIndexed bool
+	IsSynced      bool
 
 	Error *RPCError
 }
@@ -33,10 +35,12 @@ func (msg *GetInfoResponseMessage) Command() MessageCommand {
 }
 
 // NewGetInfoResponseMessage returns a instance of the message
-func NewGetInfoResponseMessage(p2pID string, mempoolSize uint64, serverVersion string) *GetInfoResponseMessage {
+func NewGetInfoResponseMessage(p2pID string, mempoolSize uint64, serverVersion string, isUtxoIndexed bool, isSynced bool) *GetInfoResponseMessage {
 	return &GetInfoResponseMessage{
 		P2PID:         p2pID,
 		MempoolSize:   mempoolSize,
 		ServerVersion: serverVersion,
+		IsUtxoIndexed: isUtxoIndexed,
+		IsSynced:      isSynced,
 	}
 }

app/appmessage/rpc_get_mempool_entries.go

@@ -4,6 +4,8 @@ package appmessage
 // its respective RPC message
 type GetMempoolEntriesRequestMessage struct {
 	baseMessage
+	IncludeOrphanPool     bool
+	FilterTransactionPool bool
 }
 
 // Command returns the protocol command string for the message
@@ -12,8 +14,11 @@ func (msg *GetMempoolEntriesRequestMessage) Command() MessageCommand {
 }
 
 // NewGetMempoolEntriesRequestMessage returns a instance of the message
-func NewGetMempoolEntriesRequestMessage() *GetMempoolEntriesRequestMessage {
-	return &GetMempoolEntriesRequestMessage{}
+func NewGetMempoolEntriesRequestMessage(includeOrphanPool bool, filterTransactionPool bool) *GetMempoolEntriesRequestMessage {
+	return &GetMempoolEntriesRequestMessage{
+		IncludeOrphanPool:     includeOrphanPool,
+		FilterTransactionPool: filterTransactionPool,
+	}
 }
 
 // GetMempoolEntriesResponseMessage is an appmessage corresponding to

app/appmessage/rpc_get_mempool_entries_by_addresses.go

@@ -0,0 +1,52 @@
+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
+	IncludeOrphanPool     bool
+	FilterTransactionPool bool
+}
+
+// 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, includeOrphanPool bool, filterTransactionPool bool) *GetMempoolEntriesByAddressesRequestMessage {
+	return &GetMempoolEntriesByAddressesRequestMessage{
+		Addresses:             addresses,
+		IncludeOrphanPool:     includeOrphanPool,
+		FilterTransactionPool: filterTransactionPool,
+	}
+}
+
+// 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_mempool_entry.go

@@ -4,7 +4,9 @@ package appmessage
 // its respective RPC message
 type GetMempoolEntryRequestMessage struct {
 	baseMessage
-	TxID string
+	TxID                  string
+	IncludeOrphanPool     bool
+	FilterTransactionPool bool
 }
 
 // Command returns the protocol command string for the message
@@ -13,8 +15,12 @@ func (msg *GetMempoolEntryRequestMessage) Command() MessageCommand {
 }
 
 // NewGetMempoolEntryRequestMessage returns a instance of the message
-func NewGetMempoolEntryRequestMessage(txID string) *GetMempoolEntryRequestMessage {
-	return &GetMempoolEntryRequestMessage{TxID: txID}
+func NewGetMempoolEntryRequestMessage(txID string, includeOrphanPool bool, filterTransactionPool bool) *GetMempoolEntryRequestMessage {
+	return &GetMempoolEntryRequestMessage{
+		TxID:                  txID,
+		IncludeOrphanPool:     includeOrphanPool,
+		FilterTransactionPool: filterTransactionPool,
+	}
 }
 
 // GetMempoolEntryResponseMessage is an appmessage corresponding to
@@ -30,6 +36,7 @@ type GetMempoolEntryResponseMessage struct {
 type MempoolEntry struct {
 	Fee         uint64
 	Transaction *RPCTransaction
+	IsOrphan    bool
 }
 
 // Command returns the protocol command string for the message
@@ -38,11 +45,12 @@ func (msg *GetMempoolEntryResponseMessage) Command() MessageCommand {
 }
 
 // NewGetMempoolEntryResponseMessage returns a instance of the message
-func NewGetMempoolEntryResponseMessage(fee uint64, transaction *RPCTransaction) *GetMempoolEntryResponseMessage {
+func NewGetMempoolEntryResponseMessage(fee uint64, transaction *RPCTransaction, isOrphan bool) *GetMempoolEntryResponseMessage {
 	return &GetMempoolEntryResponseMessage{
 		Entry: &MempoolEntry{
 			Fee:         fee,
 			Transaction: transaction,
+			IsOrphan:    isOrphan,
 		},
 	}
 }

app/appmessage/rpc_get_virtual_selected_parent_chain_from_block.go

@@ -4,7 +4,8 @@ package appmessage
 // its respective RPC message
 type GetVirtualSelectedParentChainFromBlockRequestMessage struct {
 	baseMessage
-	StartHash string
+	StartHash                     string
+	IncludeAcceptedTransactionIDs bool
 }
 
 // Command returns the protocol command string for the message
@@ -13,18 +14,29 @@ func (msg *GetVirtualSelectedParentChainFromBlockRequestMessage) Command() Messa
 }
 
 // NewGetVirtualSelectedParentChainFromBlockRequestMessage returns a instance of the message
-func NewGetVirtualSelectedParentChainFromBlockRequestMessage(startHash string) *GetVirtualSelectedParentChainFromBlockRequestMessage {
+func NewGetVirtualSelectedParentChainFromBlockRequestMessage(
+	startHash string, includeAcceptedTransactionIDs bool) *GetVirtualSelectedParentChainFromBlockRequestMessage {
+
 	return &GetVirtualSelectedParentChainFromBlockRequestMessage{
-		StartHash: startHash,
+		StartHash:                     startHash,
+		IncludeAcceptedTransactionIDs: includeAcceptedTransactionIDs,
 	}
 }
 
+// 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
 }
@@ -36,10 +48,11 @@ func (msg *GetVirtualSelectedParentChainFromBlockResponseMessage) Command() Mess
 
 // NewGetVirtualSelectedParentChainFromBlockResponseMessage returns a instance of the message
 func NewGetVirtualSelectedParentChainFromBlockResponseMessage(removedChainBlockHashes,
-	addedChainBlockHashes []string) *GetVirtualSelectedParentChainFromBlockResponseMessage {
+	addedChainBlockHashes []string, acceptedTransactionIDs []*AcceptedTransactionIDs) *GetVirtualSelectedParentChainFromBlockResponseMessage {
 
 	return &GetVirtualSelectedParentChainFromBlockResponseMessage{
 		RemovedChainBlockHashes: removedChainBlockHashes,
 		AddedChainBlockHashes:   addedChainBlockHashes,
+		AcceptedTransactionIDs:  acceptedTransactionIDs,
 	}
 }

app/appmessage/rpc_notify_virtual_selected_parent_chain_changed.go

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

app/component_manager.go

@@ -4,6 +4,8 @@ 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"
@@ -67,6 +69,7 @@ func (a *ComponentManager) Stop() {
 	}
 
 	a.protocolManager.Close()
+	close(a.protocolManager.Context().Domain().ConsensusEventsChannel())
 
 	return
 }
@@ -118,7 +121,7 @@ func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database,
 	if err != nil {
 		return nil, err
 	}
-	rpcManager := setupRPC(cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, utxoIndex, interrupt)
+	rpcManager := setupRPC(cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, utxoIndex, domain.ConsensusEventsChannel(), interrupt)
 
 	return &ComponentManager{
 		cfg:               cfg,
@@ -139,6 +142,7 @@ func setupRPC(
 	connectionManager *connmanager.ConnectionManager,
 	addressManager *addressmanager.AddressManager,
 	utxoIndex *utxoindex.UTXOIndex,
+	consensusEventsChan chan externalapi.ConsensusEvent,
 	shutDownChan chan<- struct{},
 ) *rpc.Manager {
 
@@ -150,11 +154,10 @@ func setupRPC(
 		connectionManager,
 		addressManager,
 		utxoIndex,
+		consensusEventsChan,
 		shutDownChan,
 	)
-	protocolManager.SetOnVirtualChange(rpcManager.NotifyVirtualChange)
 	protocolManager.SetOnNewBlockTemplateHandler(rpcManager.NotifyNewBlockTemplate)
-	protocolManager.SetOnBlockAddedToDAGHandler(rpcManager.NotifyBlockAddedToDAG)
 	protocolManager.SetOnPruningPointUTXOSetOverrideHandler(rpcManager.NotifyPruningPointUTXOSetOverride)
 
 	return rpcManager

app/protocol/flowcontext/blocks.go

@@ -16,60 +16,40 @@ 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,
-	virtualChangeSet *externalapi.VirtualChangeSet) error {
+func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock) error {
 
 	hash := consensushashing.BlockHash(block)
 	log.Tracef("OnNewBlock start for block %s", hash)
 	defer log.Tracef("OnNewBlock end for block %s", hash)
 
-	unorphaningResults, err := f.UnorphanBlocks(block)
+	unorphanedBlocks, err := f.UnorphanBlocks(block)
 	if err != nil {
 		return err
 	}
 
-	log.Debugf("OnNewBlock: block %s unorphaned %d blocks", hash, len(unorphaningResults))
+	log.Debugf("OnNewBlock: block %s unorphaned %d blocks", hash, len(unorphanedBlocks))
 
 	newBlocks := []*externalapi.DomainBlock{block}
-	newVirtualChangeSets := []*externalapi.VirtualChangeSet{virtualChangeSet}
-	for _, unorphaningResult := range unorphaningResults {
-		newBlocks = append(newBlocks, unorphaningResult.block)
-		newVirtualChangeSets = append(newVirtualChangeSets, unorphaningResult.virtualChangeSet)
-	}
+	newBlocks = append(newBlocks, unorphanedBlocks...)
 
 	allAcceptedTransactions := make([]*externalapi.DomainTransaction, 0)
-	for i, newBlock := range newBlocks {
+	for _, 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)
 }
 
-// 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
-}
-
 // 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()
 	}
@@ -127,7 +107,7 @@ func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
 		return protocolerrors.Errorf(false, "cannot add header only block")
 	}
 
-	virtualChangeSet, err := f.Domain().Consensus().ValidateAndInsertBlock(block, true)
+	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)
@@ -138,7 +118,7 @@ func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
 	if err != nil {
 		return err
 	}
-	err = f.OnNewBlock(block, virtualChangeSet)
+	err = f.OnNewBlock(block)
 	if err != nil {
 		return err
 	}

app/protocol/flowcontext/flow_context.go

@@ -18,13 +18,6 @@ import (
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
 )
 
-// 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
-
 // OnNewBlockTemplateHandler is a handler function that's triggered when a new block template is available
 type OnNewBlockTemplateHandler func() error
 
@@ -47,15 +40,12 @@ type FlowContext struct {
 
 	timeStarted int64
 
-	onVirtualChangeHandler               OnVirtualChangeHandler
-	onBlockAddedToDAGHandler             OnBlockAddedToDAGHandler
 	onNewBlockTemplateHandler            OnNewBlockTemplateHandler
 	onPruningPointUTXOSetOverrideHandler OnPruningPointUTXOSetOverrideHandler
 	onTransactionAddedToMempoolHandler   OnTransactionAddedToMempoolHandler
 
-	expectedDAAWindowDurationInMilliseconds int64
-	lastRebroadcastTime                     time.Time
-	sharedRequestedTransactions             *SharedRequestedTransactions
+	lastRebroadcastTime         time.Time
+	sharedRequestedTransactions *SharedRequestedTransactions
 
 	sharedRequestedBlocks *SharedRequestedBlocks
 
@@ -93,8 +83,6 @@ func New(cfg *config.Config, domain domain.Domain, addressManager *addressmanage
 		transactionIDsToPropagate:        []*externalapi.DomainTransactionID{},
 		lastTransactionIDPropagationTime: time.Now(),
 		shutdownChan:                     make(chan struct{}),
-		expectedDAAWindowDurationInMilliseconds: cfg.NetParams().TargetTimePerBlock.Milliseconds() *
-			int64(cfg.NetParams().DifficultyAdjustmentWindowSize),
 	}
 }
 
@@ -109,14 +97,9 @@ func (f *FlowContext) ShutdownChan() <-chan struct{} {
 	return f.shutdownChan
 }
 
-// SetOnVirtualChangeHandler sets the onVirtualChangeHandler handler
-func (f *FlowContext) SetOnVirtualChangeHandler(onVirtualChangeHandler OnVirtualChangeHandler) {
-	f.onVirtualChangeHandler = onVirtualChangeHandler
-}
-
-// SetOnBlockAddedToDAGHandler sets the onBlockAddedToDAG handler
-func (f *FlowContext) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler OnBlockAddedToDAGHandler) {
-	f.onBlockAddedToDAGHandler = onBlockAddedToDAGHandler
+// IsNearlySynced returns whether current consensus is considered synced or close to being synced.
+func (f *FlowContext) IsNearlySynced() (bool, error) {
+	return f.Domain().Consensus().IsNearlySynced()
 }
 
 // SetOnNewBlockTemplateHandler sets the onNewBlockTemplateHandler handler

app/protocol/flowcontext/network.go

@@ -72,3 +72,10 @@ 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,12 +15,6 @@ 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()
@@ -57,7 +51,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) ([]*UnorphaningResult, error) {
+func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*externalapi.DomainBlock, error) {
 	f.orphansMutex.Lock()
 	defer f.orphansMutex.Unlock()
 
@@ -66,7 +60,7 @@ func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*Uno
 	rootBlockHash := consensushashing.BlockHash(rootBlock)
 	processQueue := f.addChildOrphansToProcessQueue(rootBlockHash, []externalapi.DomainHash{})
 
-	var unorphaningResults []*UnorphaningResult
+	var unorphanedBlocks []*externalapi.DomainBlock
 	for len(processQueue) > 0 {
 		var orphanHash externalapi.DomainHash
 		orphanHash, processQueue = processQueue[0], processQueue[1:]
@@ -90,21 +84,18 @@ func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*Uno
 			}
 		}
 		if canBeUnorphaned {
-			virtualChangeSet, unorphaningSucceeded, err := f.unorphanBlock(orphanHash)
+			unorphaningSucceeded, err := f.unorphanBlock(orphanHash)
 			if err != nil {
 				return nil, err
 			}
 			if unorphaningSucceeded {
-				unorphaningResults = append(unorphaningResults, &UnorphaningResult{
-					block:            orphanBlock,
-					virtualChangeSet: virtualChangeSet,
-				})
+				unorphanedBlocks = append(unorphanedBlocks, orphanBlock)
 				processQueue = f.addChildOrphansToProcessQueue(&orphanHash, processQueue)
 			}
 		}
 	}
 
-	return unorphaningResults, nil
+	return unorphanedBlocks, nil
 }
 
 // addChildOrphansToProcessQueue finds all child orphans of `blockHash`
@@ -143,24 +134,24 @@ func (f *FlowContext) findChildOrphansOfBlock(blockHash *externalapi.DomainHash)
 	return childOrphans
 }
 
-func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) (*externalapi.VirtualChangeSet, bool, error) {
+func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) (bool, error) {
 	orphanBlock, ok := f.orphans[orphanHash]
 	if !ok {
-		return nil, false, errors.Errorf("attempted to unorphan a non-orphan block %s", orphanHash)
+		return false, errors.Errorf("attempted to unorphan a non-orphan block %s", orphanHash)
 	}
 	delete(f.orphans, orphanHash)
 
-	virtualChangeSet, err := f.domain.Consensus().ValidateAndInsertBlock(orphanBlock, true)
+	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 nil, false, nil
+			return false, nil
 		}
-		return nil, false, err
+		return false, err
 	}
 
 	log.Infof("Unorphaned block %s", orphanHash)
-	return virtualChangeSet, true, nil
+	return true, nil
 }
 
 // GetOrphanRoots returns the roots of the missing ancestors DAG of the given orphan

app/protocol/flowcontext/should_mine.go

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

app/protocol/flows/v5/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, message)
+			flow.invsQueue = append(flow.invsQueue, invRelayBlock{Hash: message.Hash, IsOrphanRoot: false})
 		case *appmessage.MsgBlockLocator:
 			return message.BlockLocatorHashes, nil
 		default:

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

@@ -7,6 +7,7 @@ import (
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
@@ -25,8 +26,7 @@ var orphanResolutionRange uint32 = 5
 type RelayInvsContext interface {
 	Domain() domain.Domain
 	Config() *config.Config
-	OnNewBlock(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error
-	OnVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error
+	OnNewBlock(block *externalapi.DomainBlock) error
 	OnNewBlockTemplate() error
 	OnPruningPointUTXOSetOverride() error
 	SharedRequestedBlocks() *flowcontext.SharedRequestedBlocks
@@ -39,11 +39,16 @@ type RelayInvsContext interface {
 	IsNearlySynced() (bool, error)
 }
 
+type invRelayBlock struct {
+	Hash         *externalapi.DomainHash
+	IsOrphanRoot bool
+}
+
 type handleRelayInvsFlow struct {
 	RelayInvsContext
 	incomingRoute, outgoingRoute *router.Route
 	peer                         *peerpkg.Peer
-	invsQueue                    []*appmessage.MsgInvRelayBlock
+	invsQueue                    []invRelayBlock
 }
 
 // HandleRelayInvs listens to appmessage.MsgInvRelayBlock messages, requests their corresponding blocks if they
@@ -56,7 +61,7 @@ func HandleRelayInvs(context RelayInvsContext, incomingRoute *router.Route, outg
 		incomingRoute:    incomingRoute,
 		outgoingRoute:    outgoingRoute,
 		peer:             peer,
-		invsQueue:        make([]*appmessage.MsgInvRelayBlock, 0),
+		invsQueue:        make([]invRelayBlock, 0),
 	}
 	err := flow.start()
 	// Currently, HandleRelayInvs flow is the only place where IBD is triggered, so the channel can be closed now
@@ -139,12 +144,36 @@ 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, virtualChangeSet, err := flow.processBlock(block)
+		missingParents, err := flow.processBlock(block)
 		if err != nil {
 			if errors.Is(err, ruleerrors.ErrPrunedBlock) {
 				log.Infof("Ignoring pruned block %s", inv.Hash)
@@ -203,7 +232,7 @@ func (flow *handleRelayInvsFlow) start() error {
 		}
 
 		log.Infof("Accepted block %s via relay", inv.Hash)
-		err = flow.OnNewBlock(block, virtualChangeSet)
+		err = flow.OnNewBlock(block)
 		if err != nil {
 			return err
 		}
@@ -219,24 +248,24 @@ func (flow *handleRelayInvsFlow) banIfBlockIsHeaderOnly(block *externalapi.Domai
 	return nil
 }
 
-func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error) {
+func (flow *handleRelayInvsFlow) readInv() (invRelayBlock, error) {
 	if len(flow.invsQueue) > 0 {
-		var inv *appmessage.MsgInvRelayBlock
+		var inv invRelayBlock
 		inv, flow.invsQueue = flow.invsQueue[0], flow.invsQueue[1:]
 		return inv, nil
 	}
 
 	msg, err := flow.incomingRoute.Dequeue()
 	if err != nil {
-		return nil, err
+		return invRelayBlock{}, err
 	}
 
-	inv, ok := msg.(*appmessage.MsgInvRelayBlock)
+	msgInv, ok := msg.(*appmessage.MsgInvRelayBlock)
 	if !ok {
-		return nil, protocolerrors.Errorf(true, "unexpected %s message in the block relay handleRelayInvsFlow while "+
+		return invRelayBlock{}, protocolerrors.Errorf(true, "unexpected %s message in the block relay handleRelayInvsFlow while "+
 			"expecting an inv message", msg.Command())
 	}
-	return inv, nil
+	return invRelayBlock{Hash: msgInv.Hash, IsOrphanRoot: false}, nil
 }
 
 func (flow *handleRelayInvsFlow) requestBlock(requestHash *externalapi.DomainHash) (*externalapi.DomainBlock, bool, error) {
@@ -281,7 +310,7 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock,
 
 		switch message := message.(type) {
 		case *appmessage.MsgInvRelayBlock:
-			flow.invsQueue = append(flow.invsQueue, message)
+			flow.invsQueue = append(flow.invsQueue, invRelayBlock{Hash: message.Hash, IsOrphanRoot: false})
 		case *appmessage.MsgBlock:
 			return message, nil
 		default:
@@ -290,25 +319,25 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock,
 	}
 }
 
-func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, *externalapi.VirtualChangeSet, error) {
+func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, error) {
 	blockHash := consensushashing.BlockHash(block)
-	virtualChangeSet, err := flow.Domain().Consensus().ValidateAndInsertBlock(block, true)
+	err := flow.Domain().Consensus().ValidateAndInsertBlock(block, true)
 	if err != nil {
 		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return nil, nil, errors.Wrapf(err, "failed to process block %s", blockHash)
+			return nil, errors.Wrapf(err, "failed to process block %s", blockHash)
 		}
 
 		missingParentsError := &ruleerrors.ErrMissingParents{}
 		if errors.As(err, missingParentsError) {
-			return missingParentsError.MissingParentHashes, nil, nil
+			return missingParentsError.MissingParentHashes, nil
 		}
 		// A duplicate block should not appear to the user as a warning and is already reported in the calling function
 		if !errors.Is(err, ruleerrors.ErrDuplicateBlock) {
 			log.Warnf("Rejected block %s from %s: %s", blockHash, flow.peer, err)
 		}
-		return nil, nil, protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
+		return nil, protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
 	}
-	return nil, virtualChangeSet, nil
+	return nil, nil
 }
 
 func (flow *handleRelayInvsFlow) relayBlock(block *externalapi.DomainBlock) error {
@@ -422,10 +451,10 @@ func (flow *handleRelayInvsFlow) AddOrphanRootsToQueue(orphan *externalapi.Domai
 	}
 	log.Infof("Block %s has %d missing ancestors. Adding them to the invs queue...", orphan, len(orphanRoots))
 
-	invMessages := make([]*appmessage.MsgInvRelayBlock, len(orphanRoots))
+	invMessages := make([]invRelayBlock, len(orphanRoots))
 	for i, root := range orphanRoots {
 		log.Debugf("Adding block %s missing ancestor %s to the invs queue", orphan, root)
-		invMessages[i] = appmessage.NewMsgInvBlock(root)
+		invMessages[i] = invRelayBlock{Hash: root, IsOrphanRoot: true}
 	}
 
 	flow.invsQueue = append(invMessages, flow.invsQueue...)

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

@@ -20,8 +20,7 @@ import (
 type IBDContext interface {
 	Domain() domain.Domain
 	Config() *config.Config
-	OnNewBlock(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error
-	OnVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error
+	OnNewBlock(block *externalapi.DomainBlock) error
 	OnNewBlockTemplate() error
 	OnPruningPointUTXOSetOverride() error
 	IsIBDRunning() bool
@@ -489,7 +488,7 @@ func (flow *handleIBDFlow) processHeader(consensus externalapi.Consensus, msgBlo
 		log.Debugf("Block header %s is already in the DAG. Skipping...", blockHash)
 		return nil
 	}
-	_, err = consensus.ValidateAndInsertBlock(block, false)
+	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)
@@ -567,7 +566,7 @@ func (flow *handleIBDFlow) receiveAndInsertPruningPointUTXOSet(
 
 			receivedChunkCount++
 			if receivedChunkCount%ibdBatchSize == 0 {
-				log.Debugf("Received %d UTXO set chunks so far, totaling in %d UTXOs",
+				log.Infof("Received %d UTXO set chunks so far, totaling in %d UTXOs",
 					receivedChunkCount, receivedUTXOCount)
 
 				requestNextPruningPointUTXOSetChunkMessage := appmessage.NewMsgRequestNextPruningPointUTXOSetChunk()
@@ -655,7 +654,7 @@ func (flow *handleIBDFlow) syncMissingBlockBodies(highHash *externalapi.DomainHa
 				return err
 			}
 
-			virtualChangeSet, err := flow.Domain().Consensus().ValidateAndInsertBlock(block, false)
+			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)
@@ -663,7 +662,7 @@ func (flow *handleIBDFlow) syncMissingBlockBodies(highHash *externalapi.DomainHa
 				}
 				return protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "invalid block %s", blockHash)
 			}
-			err = flow.OnNewBlock(block, virtualChangeSet)
+			err = flow.OnNewBlock(block)
 			if err != nil {
 				return err
 			}
@@ -706,12 +705,7 @@ func (flow *handleIBDFlow) resolveVirtual(estimatedVirtualDAAScoreTarget uint64)
 			}
 			log.Infof("Resolving virtual. Estimated progress: %d%%", percents)
 		}
-		virtualChangeSet, isCompletelyResolved, err := flow.Domain().Consensus().ResolveVirtual()
-		if err != nil {
-			return err
-		}
-
-		err = flow.OnVirtualChange(virtualChangeSet)
+		isCompletelyResolved, err := flow.Domain().Consensus().ResolveVirtual()
 		if err != nil {
 			return err
 		}

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

@@ -280,7 +280,7 @@ func (flow *handleIBDFlow) processBlockWithTrustedData(
 		blockWithTrustedData.GHOSTDAGData = append(blockWithTrustedData.GHOSTDAGData, appmessage.GHOSTDAGHashPairToDomainGHOSTDAGHashPair(data.GHOSTDAGData[index]))
 	}
 
-	_, err := consensus.ValidateAndInsertBlockWithTrustedData(blockWithTrustedData, false)
+	err := consensus.ValidateAndInsertBlockWithTrustedData(blockWithTrustedData, false)
 	return err
 }
 

app/protocol/manager.go

@@ -2,10 +2,11 @@ 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"
@@ -90,16 +91,6 @@ func (m *Manager) runFlows(flows []*common.Flow, peer *peerpkg.Peer, errChan <-c
 	return <-errChan
 }
 
-// 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)
-}
-
 // SetOnNewBlockTemplateHandler sets the onNewBlockTemplate handler
 func (m *Manager) SetOnNewBlockTemplateHandler(onNewBlockTemplateHandler flowcontext.OnNewBlockTemplateHandler) {
 	m.context.SetOnNewBlockTemplateHandler(onNewBlockTemplateHandler)
@@ -115,12 +106,6 @@ 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.IsNearlySynced()
-}
-
 // IsIBDRunning returns true if IBD is currently marked as running
 func (m *Manager) IsIBDRunning() bool {
 	return m.context.IsIBDRunning()

app/protocol/protocol.go

@@ -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)
+	errChan := make(chan error, 1)
 
 	receiveVersionRoute, sendVersionRoute, receiveReadyRoute := registerHandshakeRoutes(router)
 

app/rpc/manager.go

@@ -12,6 +12,7 @@ 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
@@ -28,6 +29,7 @@ func NewManager(
 	connectionManager *connmanager.ConnectionManager,
 	addressManager *addressmanager.AddressManager,
 	utxoIndex *utxoindex.UTXOIndex,
+	consensusEventsChan chan externalapi.ConsensusEvent,
 	shutDownChan chan<- struct{}) *Manager {
 
 	manager := Manager{
@@ -44,50 +46,90 @@ func NewManager(
 	}
 	netAdapter.SetRPCRouterInitializer(manager.routerInitializer)
 
+	manager.initConsensusEventsHandler(consensusEventsChan)
+
 	return &manager
 }
 
-// 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")
+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")
 	defer onEnd()
 
-	err := m.NotifyVirtualChange(virtualChangeSet)
-	if err != nil {
-		return err
+	// 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
 	}
 
 	rpcBlock := appmessage.DomainBlockToRPCBlock(block)
-	err = m.context.PopulateBlockWithVerboseData(rpcBlock, block.Header, block, false)
+	err := m.context.PopulateBlockWithVerboseData(rpcBlock, block.Header, block, true)
 	if err != nil {
 		return err
 	}
 	blockAddedNotification := appmessage.NewBlockAddedNotificationMessage(rpcBlock)
-	return m.context.NotificationManager.NotifyBlockAdded(blockAddedNotification)
+	err = m.context.NotificationManager.NotifyBlockAdded(blockAddedNotification)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
-// NotifyVirtualChange notifies the manager that the virtual block has been changed.
-func (m *Manager) NotifyVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error {
+// 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")
 	defer onEnd()
 
-	if m.context.Config.UTXOIndex {
+	if m.context.Config.UTXOIndex && virtualChangeSet.VirtualUTXODiff != nil {
 		err := m.notifyUTXOsChanged(virtualChangeSet)
 		if err != nil {
 			return err
 		}
 	}
 
-	err := m.notifyVirtualSelectedParentBlueScoreChanged()
+	err := m.notifyVirtualSelectedParentBlueScoreChanged(virtualChangeSet.VirtualSelectedParentBlueScore)
 	if err != nil {
 		return err
 	}
 
-	err = m.notifyVirtualDaaScoreChanged()
+	err = m.notifyVirtualDaaScoreChanged(virtualChangeSet.VirtualDAAScore)
 	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
@@ -145,6 +187,7 @@ func (m *Manager) notifyUTXOsChanged(virtualChangeSet *externalapi.VirtualChange
 	if err != nil {
 		return err
 	}
+
 	return m.context.NotificationManager.NotifyUTXOsChanged(utxoIndexChanges)
 }
 
@@ -160,33 +203,18 @@ func (m *Manager) notifyPruningPointUTXOSetOverride() error {
 	return m.context.NotificationManager.NotifyPruningPointUTXOSetOverride()
 }
 
-func (m *Manager) notifyVirtualSelectedParentBlueScoreChanged() error {
+func (m *Manager) notifyVirtualSelectedParentBlueScoreChanged(virtualSelectedParentBlueScore uint64) error {
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualSelectedParentBlueScoreChanged")
 	defer onEnd()
 
-	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)
+	notification := appmessage.NewVirtualSelectedParentBlueScoreChangedNotificationMessage(virtualSelectedParentBlueScore)
 	return m.context.NotificationManager.NotifyVirtualSelectedParentBlueScoreChanged(notification)
 }
 
-func (m *Manager) notifyVirtualDaaScoreChanged() error {
+func (m *Manager) notifyVirtualDaaScoreChanged(virtualDAAScore uint64) 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)
 }
@@ -195,10 +223,25 @@ func (m *Manager) notifyVirtualSelectedParentChainChanged(virtualChangeSet *exte
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualSelectedParentChainChanged")
 	defer onEnd()
 
-	notification, err := m.context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
-		virtualChangeSet.VirtualSelectedParentChainChanges)
-	if err != nil {
-		return err
+	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)
 	}
-	return m.context.NotificationManager.NotifyVirtualSelectedParentChainChanged(notification)
+
+	return nil
 }

app/rpc/rpc.go

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

app/rpc/rpccontext/chain_changed.go

@@ -3,12 +3,14 @@ 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) (*appmessage.VirtualSelectedParentChainChangedNotificationMessage, error) {
+	selectedParentChainChanges *externalapi.SelectedChainPath, includeAcceptedTransactionIDs bool) (
+	*appmessage.VirtualSelectedParentChainChangedNotificationMessage, error) {
 
 	removedChainBlockHashes := make([]string, len(selectedParentChainChanges.Removed))
 	for i, removed := range selectedParentChainChanges.Removed {
@@ -20,5 +22,58 @@ func (ctx *Context) ConvertVirtualSelectedParentChainChangesToChainChangedNotifi
 		addedChainBlocks[i] = added.String()
 	}
 
-	return appmessage.NewVirtualSelectedParentChainChangedNotificationMessage(removedChainBlockHashes, addedChainBlocks), nil
+	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))
+
+	const chunk = 1000
+	position := 0
+
+	for position < len(selectedParentChainChanges.Added) {
+		var chainBlocksChunk []*externalapi.DomainHash
+		if position+chunk > len(selectedParentChainChanges.Added) {
+			chainBlocksChunk = selectedParentChainChanges.Added[position:]
+		} else {
+			chainBlocksChunk = selectedParentChainChanges.Added[position : position+chunk]
+		}
+		// We use chunks in order to avoid blocking consensus for too long
+		chainBlocksAcceptanceData, err := ctx.Domain.Consensus().GetBlocksAcceptanceData(chainBlocksChunk)
+		if err != nil {
+			return nil, err
+		}
+
+		for i, addedChainBlock := range chainBlocksChunk {
+			chainBlockAcceptanceData := chainBlocksAcceptanceData[i]
+			acceptedTransactionIDs[position+i] = &appmessage.AcceptedTransactionIDs{
+				AcceptingBlockHash:     addedChainBlock.String(),
+				AcceptedTransactionIDs: nil,
+			}
+			for _, blockAcceptanceData := range chainBlockAcceptanceData {
+				for _, transactionAcceptanceData := range blockAcceptanceData.TransactionAcceptanceData {
+					if transactionAcceptanceData.IsAccepted {
+						acceptedTransactionIDs[position+i].AcceptedTransactionIDs =
+							append(acceptedTransactionIDs[position+i].AcceptedTransactionIDs,
+								consensushashing.TransactionID(transactionAcceptanceData.Transaction).String())
+					}
+				}
+			}
+		}
+		position += chunk
+	}
+
+	return acceptedTransactionIDs, nil
 }

app/rpc/rpccontext/context.go

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

app/rpc/rpccontext/notificationmanager.go

@@ -3,6 +3,10 @@ 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"
@@ -13,6 +17,7 @@ import (
 type NotificationManager struct {
 	sync.RWMutex
 	listeners map[*routerpkg.Router]*NotificationListener
+	params    *dagconfig.Params
 }
 
 // UTXOsChangedNotificationAddress represents a kaspad address.
@@ -24,6 +29,8 @@ type UTXOsChangedNotificationAddress struct {
 
 // NotificationListener represents a registered RPC notification listener
 type NotificationListener struct {
+	params *dagconfig.Params
+
 	propagateBlockAddedNotifications                            bool
 	propagateVirtualSelectedParentChainChangedNotifications     bool
 	propagateFinalityConflictNotifications                      bool
@@ -34,12 +41,14 @@ type NotificationListener struct {
 	propagatePruningPointUTXOSetOverrideNotifications           bool
 	propagateNewBlockTemplateNotifications                      bool
 
-	propagateUTXOsChangedNotificationAddresses map[utxoindex.ScriptPublicKeyString]*UTXOsChangedNotificationAddress
+	propagateUTXOsChangedNotificationAddresses                                    map[utxoindex.ScriptPublicKeyString]*UTXOsChangedNotificationAddress
+	includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications bool
 }
 
 // NewNotificationManager creates a new NotificationManager
-func NewNotificationManager() *NotificationManager {
+func NewNotificationManager(params *dagconfig.Params) *NotificationManager {
 	return &NotificationManager{
+		params:    params,
 		listeners: make(map[*routerpkg.Router]*NotificationListener),
 	}
 }
@@ -49,7 +58,7 @@ func (nm *NotificationManager) AddListener(router *routerpkg.Router) {
 	nm.Lock()
 	defer nm.Unlock()
 
-	listener := newNotificationListener()
+	listener := newNotificationListener(nm.params)
 	nm.listeners[router] = listener
 }
 
@@ -73,6 +82,19 @@ 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()
@@ -80,10 +102,8 @@ func (nm *NotificationManager) NotifyBlockAdded(notification *appmessage.BlockAd
 
 	for router, listener := range nm.listeners {
 		if listener.propagateBlockAddedNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
-			if errors.Is(err, routerpkg.ErrRouteClosed) {
-				log.Warnf("Couldn't send notification: %s", err)
-			} else if err != nil {
+			err := router.OutgoingRoute().MaybeEnqueue(notification)
+			if err != nil {
 				return err
 			}
 		}
@@ -92,13 +112,27 @@ 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 {
-			err := router.OutgoingRoute().Enqueue(notification)
+			var err error
+
+			if listener.includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications {
+				err = router.OutgoingRoute().MaybeEnqueue(notification)
+			} else {
+				err = router.OutgoingRoute().MaybeEnqueue(notificationWithoutAcceptedTransactionIDs)
+			}
+
 			if err != nil {
 				return err
 			}
@@ -107,6 +141,18 @@ func (nm *NotificationManager) NotifyVirtualSelectedParentChainChanged(notificat
 	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()
@@ -147,7 +193,10 @@ func (nm *NotificationManager) NotifyUTXOsChanged(utxoChanges *utxoindex.UTXOCha
 	for router, listener := range nm.listeners {
 		if listener.propagateUTXOsChangedNotifications {
 			// Filter utxoChanges and create a notification
-			notification := listener.convertUTXOChangesToUTXOsChangedNotification(utxoChanges)
+			notification, err := listener.convertUTXOChangesToUTXOsChangedNotification(utxoChanges)
+			if err != nil {
+				return err
+			}
 
 			// Don't send the notification if it's empty
 			if len(notification.Added) == 0 && len(notification.Removed) == 0 {
@@ -155,7 +204,7 @@ func (nm *NotificationManager) NotifyUTXOsChanged(utxoChanges *utxoindex.UTXOCha
 			}
 
 			// Enqueue the notification
-			err := router.OutgoingRoute().Enqueue(notification)
+			err = router.OutgoingRoute().MaybeEnqueue(notification)
 			if err != nil {
 				return err
 			}
@@ -174,7 +223,7 @@ func (nm *NotificationManager) NotifyVirtualSelectedParentBlueScoreChanged(
 
 	for router, listener := range nm.listeners {
 		if listener.propagateVirtualSelectedParentBlueScoreChangedNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
+			err := router.OutgoingRoute().MaybeEnqueue(notification)
 			if err != nil {
 				return err
 			}
@@ -193,7 +242,7 @@ func (nm *NotificationManager) NotifyVirtualDaaScoreChanged(
 
 	for router, listener := range nm.listeners {
 		if listener.propagateVirtualDaaScoreChangedNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
+			err := router.OutgoingRoute().MaybeEnqueue(notification)
 			if err != nil {
 				return err
 			}
@@ -238,8 +287,10 @@ func (nm *NotificationManager) NotifyPruningPointUTXOSetOverride() error {
 	return nil
 }
 
-func newNotificationListener() *NotificationListener {
+func newNotificationListener(params *dagconfig.Params) *NotificationListener {
 	return &NotificationListener{
+		params: params,
+
 		propagateBlockAddedNotifications:                            false,
 		propagateVirtualSelectedParentChainChangedNotifications:     false,
 		propagateFinalityConflictNotifications:                      false,
@@ -251,6 +302,12 @@ func newNotificationListener() *NotificationListener {
 	}
 }
 
+// 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() {
@@ -259,8 +316,9 @@ func (nl *NotificationListener) PropagateBlockAddedNotifications() {
 
 // PropagateVirtualSelectedParentChainChangedNotifications instructs the listener to send chain changed notifications
 // to the remote listener
-func (nl *NotificationListener) PropagateVirtualSelectedParentChainChangedNotifications() {
+func (nl *NotificationListener) PropagateVirtualSelectedParentChainChangedNotifications(includeAcceptedTransactionIDs bool) {
 	nl.propagateVirtualSelectedParentChainChangedNotifications = true
+	nl.includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications = includeAcceptedTransactionIDs
 }
 
 // PropagateFinalityConflictNotifications instructs the listener to send finality conflict notifications
@@ -305,7 +363,7 @@ func (nl *NotificationListener) StopPropagatingUTXOsChangedNotifications(address
 }
 
 func (nl *NotificationListener) convertUTXOChangesToUTXOsChangedNotification(
-	utxoChanges *utxoindex.UTXOChanges) *appmessage.UTXOsChangedNotificationMessage {
+	utxoChanges *utxoindex.UTXOChanges) (*appmessage.UTXOsChangedNotificationMessage, error) {
 
 	// As an optimization, we iterate over the smaller set (O(n)) among the two below
 	// and check existence over the larger set (O(1))
@@ -320,27 +378,64 @@ func (nl *NotificationListener) convertUTXOChangesToUTXOsChangedNotification(
 				notification.Added = append(notification.Added, utxosByAddressesEntries...)
 			}
 		}
-		for scriptPublicKeyString, removedOutpoints := range utxoChanges.Removed {
+		for scriptPublicKeyString, removedPairs := range utxoChanges.Removed {
 			if listenerAddress, ok := nl.propagateUTXOsChangedNotificationAddresses[scriptPublicKeyString]; ok {
-				utxosByAddressesEntries := convertUTXOOutpointsToUTXOsByAddressesEntries(listenerAddress.Address, removedOutpoints)
+				utxosByAddressesEntries := ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(listenerAddress.Address, removedPairs)
 				notification.Removed = append(notification.Removed, utxosByAddressesEntries...)
 			}
 		}
-	} else {
+	} else if addressesSize > 0 {
 		for _, listenerAddress := range nl.propagateUTXOsChangedNotificationAddresses {
 			listenerScriptPublicKeyString := listenerAddress.ScriptPublicKeyString
 			if addedPairs, ok := utxoChanges.Added[listenerScriptPublicKeyString]; ok {
 				utxosByAddressesEntries := ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(listenerAddress.Address, addedPairs)
 				notification.Added = append(notification.Added, utxosByAddressesEntries...)
 			}
-			if removedOutpoints, ok := utxoChanges.Removed[listenerScriptPublicKeyString]; ok {
-				utxosByAddressesEntries := convertUTXOOutpointsToUTXOsByAddressesEntries(listenerAddress.Address, removedOutpoints)
+			if removedPairs, ok := utxoChanges.Removed[listenerScriptPublicKeyString]; ok {
+				utxosByAddressesEntries := ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(listenerAddress.Address, removedPairs)
 				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, removedPAirs := range utxoChanges.Removed {
+			addressString, err := nl.scriptPubKeyStringToAddressString(scriptPublicKeyString)
+			if err != nil {
+				return nil, err
+			}
+
+			utxosByAddressesEntries := ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(addressString, removedPAirs)
+			notification.Removed = append(notification.Removed, utxosByAddressesEntries...)
+		}
 	}
 
-	return notification
+	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
 }
 
 // PropagateVirtualSelectedParentBlueScoreChangedNotifications instructs the listener to send

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

@@ -28,7 +28,8 @@ func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, reque
 	}
 
 	coinbaseData := &externalapi.DomainCoinbaseData{ScriptPublicKey: scriptPublicKey, ExtraData: []byte(version.Version() + "/" + getBlockTemplateRequest.ExtraData)}
-	templateBlock, err := context.Domain.MiningManager().GetBlockTemplate(coinbaseData)
+
+	templateBlock, isNearlySynced, err := context.Domain.MiningManager().GetBlockTemplate(coinbaseData)
 	if err != nil {
 		return nil, err
 	}
@@ -41,10 +42,5 @@ func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, reque
 
 	rpcBlock := appmessage.DomainBlockToRPCBlock(templateBlock)
 
-	isSynced, err := context.ProtocolManager.ShouldMine()
-	if err != nil {
-		return nil, err
-	}
-
-	return appmessage.NewGetBlockTemplateResponseMessage(rpcBlock, isSynced), nil
+	return appmessage.NewGetBlockTemplateResponseMessage(rpcBlock, context.ProtocolManager.Context().HasPeers() && isNearlySynced), nil
 }

app/rpc/rpchandlers/get_blocks_test.go

@@ -23,6 +23,10 @@ type fakeDomain struct {
 	testapi.TestConsensus
 }
 
+func (d fakeDomain) ConsensusEventsChannel() chan externalapi.ConsensusEvent {
+	panic("implement me")
+}
+
 func (d fakeDomain) DeleteStagingConsensus() error {
 	panic("implement me")
 }

app/rpc/rpchandlers/get_coin_supply.go

@@ -0,0 +1,29 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleGetCoinSupply handles the respectively named RPC command
+func HandleGetCoinSupply(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	if !context.Config.UTXOIndex {
+		errorMessage := &appmessage.GetCoinSupplyResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --utxoindex")
+		return errorMessage, nil
+	}
+
+	circulatingSompiSupply, err := context.UTXOIndex.GetCirculatingSompiSupply()
+	if err != nil {
+		return nil, err
+	}
+
+	response := appmessage.NewGetCoinSupplyResponseMessage(
+		constants.MaxSompi,
+		circulatingSompiSupply,
+	)
+
+	return response, nil
+}

app/rpc/rpchandlers/get_info.go

@@ -9,10 +9,17 @@ import (
 
 // HandleGetInfo handles the respectively named RPC command
 func HandleGetInfo(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	isNearlySynced, err := context.Domain.Consensus().IsNearlySynced()
+	if err != nil {
+		return nil, err
+	}
+
 	response := appmessage.NewGetInfoResponseMessage(
 		context.NetAdapter.ID().String(),
 		uint64(context.Domain.MiningManager().TransactionCount()),
 		version.Version(),
+		context.Config.UTXOIndex,
+		context.ProtocolManager.Context().HasPeers() && isNearlySynced,
 	)
 
 	return response, nil

app/rpc/rpchandlers/get_mempool_entries.go

@@ -7,7 +7,32 @@ import (
 )
 
 // HandleGetMempoolEntries handles the respectively named RPC command
-func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	getMempoolEntriesRequest := request.(*appmessage.GetMempoolEntriesRequestMessage)
+
+	entries := make([]*appmessage.MempoolEntry, 0)
+
+	if !getMempoolEntriesRequest.FilterTransactionPool {
+		transactionPoolEntries, err := getTransactionPoolMempoolEntries(context)
+		if err != nil {
+			return nil, err
+		}
+
+		entries = append(entries, transactionPoolEntries...)
+	}
+
+	if getMempoolEntriesRequest.IncludeOrphanPool {
+		orphanPoolEntries, err := getOrphanPoolMempoolEntries(context)
+		if err != nil {
+			return nil, err
+		}
+		entries = append(entries, orphanPoolEntries...)
+	}
+
+	return appmessage.NewGetMempoolEntriesResponseMessage(entries), nil
+}
+
+func getTransactionPoolMempoolEntries(context *rpccontext.Context) ([]*appmessage.MempoolEntry, error) {
 	transactions := context.Domain.MiningManager().AllTransactions()
 	entries := make([]*appmessage.MempoolEntry, 0, len(transactions))
 	for _, transaction := range transactions {
@@ -19,8 +44,26 @@ func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, _ ap
 		entries = append(entries, &appmessage.MempoolEntry{
 			Fee:         transaction.Fee,
 			Transaction: rpcTransaction,
+			IsOrphan:    false,
 		})
 	}
-
-	return appmessage.NewGetMempoolEntriesResponseMessage(entries), nil
+	return entries, nil
+}
+
+func getOrphanPoolMempoolEntries(context *rpccontext.Context) ([]*appmessage.MempoolEntry, error) {
+	orphanTransactions := context.Domain.MiningManager().AllOrphanTransactions()
+	entries := make([]*appmessage.MempoolEntry, 0, len(orphanTransactions))
+	for _, orphanTransaction := range orphanTransactions {
+		rpcTransaction := appmessage.DomainTransactionToRPCTransaction(orphanTransaction)
+		err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
+		if err != nil {
+			return nil, err
+		}
+		entries = append(entries, &appmessage.MempoolEntry{
+			Fee:         orphanTransaction.Fee,
+			Transaction: rpcTransaction,
+			IsOrphan:    true,
+		})
+	}
+	return entries, nil
 }

app/rpc/rpchandlers/get_mempool_entries_by_addresses.go

@@ -0,0 +1,147 @@
+package rpchandlers
+
+import (
+	"errors"
+
+	"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/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) {
+
+	getMempoolEntriesByAddressesRequest := request.(*appmessage.GetMempoolEntriesByAddressesRequestMessage)
+
+	mempoolEntriesByAddresses := make([]*appmessage.MempoolEntryByAddress, 0)
+
+	if !getMempoolEntriesByAddressesRequest.FilterTransactionPool {
+		transactionPoolTransactions := context.Domain.MiningManager().AllTransactions()
+		transactionPoolEntriesByAddresses, err := extractMempoolEntriesByAddressesFromTransactions(
+			context,
+			getMempoolEntriesByAddressesRequest.Addresses,
+			transactionPoolTransactions,
+			false,
+		)
+		if err != nil {
+			rpcError := &appmessage.RPCError{}
+			if !errors.As(err, &rpcError) {
+				return nil, err
+			}
+			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
+			errorMessage.Error = rpcError
+			return errorMessage, nil
+		}
+		mempoolEntriesByAddresses = append(mempoolEntriesByAddresses, transactionPoolEntriesByAddresses...)
+	}
+
+	if getMempoolEntriesByAddressesRequest.IncludeOrphanPool {
+
+		orphanPoolTransactions := context.Domain.MiningManager().AllOrphanTransactions()
+		orphanPoolEntriesByAddresse, err := extractMempoolEntriesByAddressesFromTransactions(
+			context,
+			getMempoolEntriesByAddressesRequest.Addresses,
+			orphanPoolTransactions,
+			true,
+		)
+		if err != nil {
+			rpcError := &appmessage.RPCError{}
+			if !errors.As(err, &rpcError) {
+				return nil, err
+			}
+			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
+			errorMessage.Error = rpcError
+			return errorMessage, nil
+		}
+
+		mempoolEntriesByAddresses = append(mempoolEntriesByAddresses, orphanPoolEntriesByAddresse...)
+	}
+
+	return appmessage.NewGetMempoolEntriesByAddressesResponseMessage(mempoolEntriesByAddresses), nil
+}
+
+//TO DO: optimize extractMempoolEntriesByAddressesFromTransactions
+func extractMempoolEntriesByAddressesFromTransactions(context *rpccontext.Context, addresses []string, transactions []*externalapi.DomainTransaction, areOrphans bool) ([]*appmessage.MempoolEntryByAddress, error) {
+	mempoolEntriesByAddresses := make([]*appmessage.MempoolEntryByAddress, 0)
+	for _, addressString := range addresses {
+		_, err := util.DecodeAddress(addressString, context.Config.ActiveNetParams.Prefix)
+		if err != nil {
+			return nil, appmessage.RPCErrorf("Could not decode address '%s': %s", addressString, err)
+		}
+
+		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,
+							IsOrphan:    areOrphans,
+						},
+					)
+					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,
+							IsOrphan:    areOrphans,
+						},
+					)
+					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 mempoolEntriesByAddresses, nil
+}

app/rpc/rpchandlers/get_mempool_entry.go

@@ -3,12 +3,18 @@ package rpchandlers
 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/transactionid"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
 // HandleGetMempoolEntry handles the respectively named RPC command
 func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+
+	transaction := &externalapi.DomainTransaction{}
+	var found bool
+	var isOrphan bool
+
 	getMempoolEntryRequest := request.(*appmessage.GetMempoolEntryRequestMessage)
 
 	transactionID, err := transactionid.FromString(getMempoolEntryRequest.TxID)
@@ -18,17 +24,25 @@ func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, reques
 		return errorMessage, nil
 	}
 
-	transaction, ok := context.Domain.MiningManager().GetTransaction(transactionID)
-	if !ok {
+	if !getMempoolEntryRequest.FilterTransactionPool {
+		transaction, found = context.Domain.MiningManager().GetTransaction(transactionID)
+	}
+
+	if getMempoolEntryRequest.IncludeOrphanPool && !found {
+		transaction, found = context.Domain.MiningManager().GetOrphanTransaction(transactionID)
+		isOrphan = true
+	}
+
+	if !found {
 		errorMessage := &appmessage.GetMempoolEntryResponseMessage{}
 		errorMessage.Error = appmessage.RPCErrorf("Transaction %s was not found", transactionID)
 		return errorMessage, nil
 	}
+
 	rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
 	err = context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
 	if err != nil {
 		return nil, err
 	}
-
-	return appmessage.NewGetMempoolEntryResponseMessage(transaction.Fee, rpcTransaction), nil
+	return appmessage.NewGetMempoolEntryResponseMessage(transaction.Fee, rpcTransaction, isOrphan), nil
 }

app/rpc/rpchandlers/get_virtual_selected_parent_chain_from_block.go

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

app/rpc/rpchandlers/notify_virtual_selected_parent_chain_changed.go

@@ -7,12 +7,17 @@ import (
 )
 
 // HandleNotifyVirtualSelectedParentChainChanged handles the respectively named RPC command
-func HandleNotifyVirtualSelectedParentChainChanged(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+func HandleNotifyVirtualSelectedParentChainChanged(context *rpccontext.Context, router *router.Router,
+	request appmessage.Message) (appmessage.Message, error) {
+
+	notifyVirtualSelectedParentChainChangedRequest := request.(*appmessage.NotifyVirtualSelectedParentChainChangedRequestMessage)
+
 	listener, err := context.NotificationManager.Listener(router)
 	if err != nil {
 		return nil, err
 	}
-	listener.PropagateVirtualSelectedParentChainChangedNotifications()
+	listener.PropagateVirtualSelectedParentChainChangedNotifications(
+		notifyVirtualSelectedParentChainChangedRequest.IncludeAcceptedTransactionIDs)
 
 	response := appmessage.NewNotifyVirtualSelectedParentChainChangedResponseMessage()
 	return response, nil

app/rpc/rpchandlers/submit_block.go

@@ -15,9 +15,14 @@ import (
 func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
 	submitBlockRequest := request.(*appmessage.SubmitBlockRequestMessage)
 
-	isSynced, err := context.ProtocolManager.ShouldMine()
-	if err != nil {
-		return nil, err
+	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
+		}
 	}
 
 	if !context.Config.AllowSubmitBlockWhenNotSynced && !isSynced {

changelog.txt

@@ -1,3 +1,74 @@
+Kaspad v0.12.2 - 2022-06-17
+===========================
+
+* Clarify wallet message concerning a wallet daemon sync state  (#2045)
+* Change the way the miner executable reports execution errors (closes issue #1677) (#2048)
+* Fix kaspawallet help messages, clarify sweep command help string (#2067)
+* Wallet parse/send/create commands improvement (#2024)
+* Use chunks for `GetBlocksAcceptanceData` calls in order to avoid blocking consensus for too long (#2075)
+* Unite multiple `GetBlockAcceptanceData` consensus calls to one (#2074)
+* Update many-small-chains-and-one-big-chain DAG to not fail merge depth limit (#2072)
+
+RPC API Changes:
+* RPC: include orphans into mempool entries (#2046)
+* RPC & UtxoIndex: keep track of, query and test circulating supply. (#2070)
+
+Bug Fixes:
+* Fix RPC connections counting (#2026)
+* Fix UTXO diff child error  (#2084)
+* Fix `not in selected chain` crash  (#2082)
+
+Kaspad v0.12.1 - 2022-05-31
+===========================
+
+* Fix utxoindex synchronization bug which resulted in kaspawallet orphan tx errors (#2052, #2056, #2059)
+* Add a channel mechanism for consensus events to be processed in the order they were produced (#2052, #2056, #2059)
+* Block template cache improvement (#2023)
+* Improved staging shard performance (#2034)
+* Add finality check to ResolveVirtual (#2041)
+* Update Dockerfile for go 1.18 (#2038)
+* Remove HF1 activation code (#2042)
+
+Kaspa wallet:
+* Various kaspawallet text fixes and log additions (#2032, #2047, #2062)
+* Wallet address synchronization improvement (#2025)
+* Add support for `from` address in `kaspawallet send` (#1964)
+* Make kaspawallet ignore outputs that exist in the mempool (#2053)
+* Wrap the entire wallet send operation with a lock (#2063)
+
+RPC API:
+* Add "GetMempoolEntriesByAddresses" to kaspad RPC (#2022)
+* Make sure RPCErrors are returned and do not crash the system (#2039)
+* Add AcceptedTransactionIDs to ChainChanged notification and VirtualSelectedParentChain RPC (#2036, for exchanges to track tx confirmations)
+* Allow blank address in NotifyUTXOsChanged to get all updates (#2027)
+* Include isSynced and isUtxoIndexed in GetInfoResponse (#2068)
+
+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)

cmd/kaspactl/commands.go

@@ -31,10 +31,13 @@ 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{}),
 	reflect.TypeOf(protowire.KaspadMessage_GetBalanceByAddressRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetCoinSupplyRequest{}),
 
 	reflect.TypeOf(protowire.KaspadMessage_BanRequest{}),
 	reflect.TypeOf(protowire.KaspadMessage_UnbanRequest{}),

cmd/kaspaminer/main.go

@@ -23,8 +23,7 @@ func main() {
 
 	cfg, err := parseConfig()
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error parsing command-line arguments: %s\n", err)
-		os.Exit(1)
+		printErrorAndExit(errors.Errorf("Error parsing command-line arguments: %s", err))
 	}
 	defer backendLog.Close()
 
@@ -44,7 +43,7 @@ func main() {
 
 	miningAddr, err := util.DecodeAddress(cfg.MiningAddr, cfg.ActiveNetParams.Prefix)
 	if err != nil {
-		panic(errors.Wrap(err, "error decoding mining address"))
+		printErrorAndExit(errors.Errorf("Error decoding mining address: %s", err))
 	}
 
 	doneChan := make(chan struct{})
@@ -61,3 +60,8 @@ func main() {
 	case <-interrupt:
 	}
 }
+
+func printErrorAndExit(err error) {
+	fmt.Fprintf(os.Stderr, "%+v\n", err)
+	os.Exit(1)
+}

cmd/kaspawallet/balance.go

@@ -3,19 +3,12 @@ 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/domain/consensus/utils/constants"
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/utils"
 )
 
-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 {
@@ -39,12 +32,12 @@ func balance(conf *balanceConfig) error {
 		println("Address                                                                       Available             Pending")
 		println("-----------------------------------------------------------------------------------------------------------")
 		for _, addressBalance := range response.AddressBalances {
-			fmt.Printf("%s %s %s\n", addressBalance.Address, formatKas(addressBalance.Available), formatKas(addressBalance.Pending))
+			fmt.Printf("%s %s %s\n", addressBalance.Address, utils.FormatKas(addressBalance.Available), utils.FormatKas(addressBalance.Pending))
 		}
 		println("-----------------------------------------------------------------------------------------------------------")
 		print("                                                 ")
 	}
-	fmt.Printf("Total balance, KAS %s %s%s\n", formatKas(response.Available), formatKas(response.Pending), pendingSuffix)
+	fmt.Printf("Total balance, KAS %s %s%s\n", utils.FormatKas(response.Available), utils.FormatKas(response.Pending), pendingSuffix)
 
 	return nil
 }

cmd/kaspawallet/broadcast.go

@@ -42,18 +42,14 @@ func broadcast(conf *broadcastConfig) error {
 		return err
 	}
 
-	transactionsCount := len(transactions)
-	for i, transaction := range transactions {
-		response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{Transaction: transaction})
-		if err != nil {
-			return err
-		}
-		if transactionsCount == 1 {
-			fmt.Println("Transaction was sent successfully")
-		} else {
-			fmt.Printf("Transaction %d (out of %d) was sent successfully\n", i+1, transactionsCount)
-		}
-		fmt.Printf("Transaction ID: \t%s\n", response.TxID)
+	response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{Transactions: transactions})
+	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)
 	}
 
 	return nil

cmd/kaspawallet/config.go

@@ -13,6 +13,7 @@ const (
 	createSubCmd                    = "create"
 	balanceSubCmd                   = "balance"
 	sendSubCmd                      = "send"
+	sweepSubCmd                     = "sweep"
 	createUnsignedTransactionSubCmd = "create-unsigned-transaction"
 	signSubCmd                      = "sign"
 	broadcastSubCmd                 = "broadcast"
@@ -45,24 +46,32 @@ type createConfig struct {
 }
 
 type balanceConfig struct {
-	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
 	Verbose       bool   `long:"verbose" short:"v" description:"Verbose: show addresses with balance"`
 	config.NetworkFlags
 }
 
 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"`
-	SendAmount    float64 `long:"send-amount" short:"v" description:"An amount to send in Kaspa (e.g. 1234.12345678)" required:"true"`
+	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"`
+	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"`
 	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"`
-	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"`
+	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
 }
 
@@ -75,7 +84,7 @@ type signConfig struct {
 }
 
 type broadcastConfig struct {
-	DaemonAddress    string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	DaemonAddress    string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
 	Transactions     string `long:"transaction" short:"t" description:"The signed transaction to broadcast (encoded in hex)"`
 	TransactionsFile string `long:"transaction-file" short:"F" description:"The file containing the unsigned transaction to sign on (encoded in hex)"`
 	config.NetworkFlags
@@ -89,12 +98,12 @@ type parseConfig struct {
 }
 
 type showAddressesConfig struct {
-	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
 	config.NetworkFlags
 }
 
 type newAddressConfig struct {
-	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
 	config.NetworkFlags
 }
 
@@ -130,6 +139,12 @@ 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 schnorr private key to a new address of the current wallet",
+		"Sends all funds associated with the given schnorr private key to a newly created external (i.e. not a change) address of the "+
+			"keyfile that is under the daemon's contol. Can be used with a private key generated with the genkeypair utilily "+
+			"to send funds to your main wallet.", sweepConf)
+
 	createUnsignedTransactionConf := &createUnsignedTransactionConfig{DaemonAddress: defaultListen}
 	parser.AddCommand(createUnsignedTransactionSubCmd, "Create an unsigned Kaspa transaction",
 		"Create an unsigned Kaspa transaction", createUnsignedTransactionConf)
@@ -199,6 +214,13 @@ 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

@@ -3,11 +3,12 @@ package main
 import (
 	"bufio"
 	"fmt"
+	"os"
+
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet/bip32"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/utils"
 	"github.com/pkg/errors"
-	"os"
 
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/keys"
 )
@@ -30,6 +31,10 @@ func create(conf *createConfig) error {
 		fmt.Printf("Extended public key of mnemonic #%d:\n%s\n\n", i+1, extendedPublicKey)
 	}
 
+	fmt.Printf("Notice the above is neither a secret key to your wallet " +
+		"(use \"kaspawallet dump-unencrypted-data\" to see a secret seed phrase) " +
+		"nor a wallet public address (use \"kaspawallet new-address\" to create and see one)\n\n")
+
 	extendedPublicKeys := make([]string, conf.NumPrivateKeys, conf.NumPublicKeys)
 	copy(extendedPublicKeys, signerExtendedPublicKeys)
 	reader := bufio.NewReader(os.Stdin)
@@ -50,9 +55,13 @@ func create(conf *createConfig) error {
 		extendedPublicKeys = append(extendedPublicKeys, string(extendedPublicKey))
 	}
 
-	cosignerIndex, err := libkaspawallet.MinimumCosignerIndex(signerExtendedPublicKeys, extendedPublicKeys)
-	if err != nil {
-		return err
+	// 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
+		}
 	}
 
 	file := keys.File{

cmd/kaspawallet/create_unsigned_tx.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
+	"os"
 
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
@@ -21,6 +22,7 @@ func createUnsignedTransaction(conf *createUnsignedTransactionConfig) error {
 
 	sendAmountSompi := uint64(conf.SendAmount * constants.SompiPerKaspa)
 	response, err := daemonClient.CreateUnsignedTransactions(ctx, &pb.CreateUnsignedTransactionsRequest{
+		From:    conf.FromAddresses,
 		Address: conf.ToAddress,
 		Amount:  sendAmountSompi,
 	})
@@ -28,7 +30,8 @@ func createUnsignedTransaction(conf *createUnsignedTransactionConfig) error {
 		return err
 	}
 
-	fmt.Println("Created unsigned transaction")
+	fmt.Fprintln(os.Stderr, "Created unsigned transaction")
 	fmt.Println(encodeTransactionsToHex(response.UnsignedTransactions))
+
 	return nil
 }

cmd/kaspawallet/daemon/pb/kaspawalletd.proto

@@ -5,11 +5,16 @@ package kaspawalletd;
 
 service kaspawalletd {
   rpc GetBalance (GetBalanceRequest) returns (GetBalanceResponse) {}
+  rpc GetExternalSpendableUTXOs (GetExternalSpendableUTXOsRequest) returns (GetExternalSpendableUTXOsResponse) {}
   rpc CreateUnsignedTransactions (CreateUnsignedTransactionsRequest) returns (CreateUnsignedTransactionsResponse) {}
   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 {
@@ -22,14 +27,15 @@ message GetBalanceResponse {
 }
 
 message AddressBalances {
-    string address = 1;
-    uint64 available = 2;
-    uint64 pending = 3;
+  string address = 1;
+  uint64 available = 2;
+  uint64 pending = 3;
 }
 
 message CreateUnsignedTransactionsRequest {
   string address = 1;
   uint64 amount = 2;
+  repeated string from = 3;
 }
 
 message CreateUnsignedTransactionsResponse {
@@ -51,11 +57,12 @@ message NewAddressResponse {
 }
 
 message BroadcastRequest {
-  bytes transaction = 1;
+        bool isDomain = 1;  
+        repeated bytes transactions = 2;
 }
 
 message BroadcastResponse {
-  string txID = 1;
+  repeated string txIDs = 1;
 }
 
 message ShutdownRequest {
@@ -63,3 +70,55 @@ 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,4 +1,8 @@
 // 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
 
@@ -19,11 +23,16 @@ 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)
 	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 {
@@ -43,6 +52,15 @@ func (c *kaspawalletdClient) GetBalance(ctx context.Context, in *GetBalanceReque
 	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...)
@@ -88,16 +106,39 @@ func (c *kaspawalletdClient) Broadcast(ctx context.Context, in *BroadcastRequest
 	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...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // KaspawalletdServer is the server API for Kaspawalletd service.
 // All implementations must embed UnimplementedKaspawalletdServer
 // for forward compatibility
 type KaspawalletdServer interface {
 	GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error)
+	GetExternalSpendableUTXOs(context.Context, *GetExternalSpendableUTXOsRequest) (*GetExternalSpendableUTXOsResponse, error)
 	CreateUnsignedTransactions(context.Context, *CreateUnsignedTransactionsRequest) (*CreateUnsignedTransactionsResponse, error)
 	ShowAddresses(context.Context, *ShowAddressesRequest) (*ShowAddressesResponse, error)
 	NewAddress(context.Context, *NewAddressRequest) (*NewAddressResponse, error)
 	Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error)
 	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()
 }
 
@@ -108,6 +149,9 @@ 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")
 }
@@ -123,6 +167,12 @@ 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.
@@ -154,6 +204,24 @@ 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)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(KaspawalletdServer).GetExternalSpendableUTXOs(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/kaspawalletd.kaspawalletd/GetExternalSpendableUTXOs",
+	}
+	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 {
@@ -244,6 +312,42 @@ 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)
@@ -255,6 +359,10 @@ var Kaspawalletd_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "GetBalance",
 			Handler:    _Kaspawalletd_GetBalance_Handler,
 		},
+		{
+			MethodName: "GetExternalSpendableUTXOs",
+			Handler:    _Kaspawalletd_GetExternalSpendableUTXOs_Handler,
+		},
 		{
 			MethodName: "CreateUnsignedTransactions",
 			Handler:    _Kaspawalletd_CreateUnsignedTransactions_Handler,
@@ -275,6 +383,14 @@ 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

@@ -39,10 +39,10 @@ func (s *server) ShowAddresses(_ context.Context, request *pb.ShowAddressesReque
 	defer s.lock.Unlock()
 
 	if !s.isSynced() {
-		return nil, errors.New("server is not synced")
+		return nil, errors.Errorf("wallet daemon is not synced yet, %s", s.formatSyncStateReport())
 	}
 
-	addresses := make([]string, 0)
+	addresses := make([]string, s.keysFile.LastUsedExternalIndex())
 	for i := uint32(1); i <= s.keysFile.LastUsedExternalIndex(); i++ {
 		walletAddr := &walletAddress{
 			index:         i,
@@ -54,7 +54,7 @@ func (s *server) ShowAddresses(_ context.Context, request *pb.ShowAddressesReque
 		if err != nil {
 			return nil, err
 		}
-		addresses = append(addresses, address.String())
+		addresses[i-1] = address.String()
 	}
 
 	return &pb.ShowAddressesResponse{Address: addresses}, nil
@@ -65,7 +65,7 @@ func (s *server) NewAddress(_ context.Context, request *pb.NewAddressRequest) (*
 	defer s.lock.Unlock()
 
 	if !s.isSynced() {
-		return nil, errors.New("server is not synced")
+		return nil, errors.Errorf("wallet daemon is not synced yet, %s", s.formatSyncStateReport())
 	}
 
 	err := s.keysFile.SetLastUsedExternalIndex(s.keysFile.LastUsedExternalIndex() + 1)

cmd/kaspawallet/daemon/server/broadcast.go

@@ -2,27 +2,64 @@ 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) {
-	tx, err := libkaspawallet.ExtractTransaction(request.Transaction, s.keysFile.ECDSA)
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	txIDs, err := s.broadcast(request.Transactions, request.IsDomain)
 	if err != nil {
 		return nil, err
 	}
 
-	txID, err := sendTransaction(s.rpcClient, tx)
+	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()
 	if err != nil {
 		return nil, err
 	}
 
-	return &pb.BroadcastResponse{TxID: txID}, nil
+	return txIDs, nil
 }
 
 func sendTransaction(client *rpcclient.RPCClient, tx *externalapi.DomainTransaction) (string, error) {

cmd/kaspawallet/daemon/server/create_unsigned_transaction.go

@@ -2,12 +2,14 @@ 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
@@ -18,8 +20,17 @@ func (s *server) CreateUnsignedTransactions(_ context.Context, request *pb.Creat
 	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")
+		return nil, errors.Errorf("wallet daemon is not synced yet, %s", s.formatSyncStateReport())
 	}
 
 	err := s.refreshUTXOs()
@@ -27,12 +38,21 @@ func (s *server) CreateUnsignedTransactions(_ context.Context, request *pb.Creat
 		return nil, err
 	}
 
-	toAddress, err := util.DecodeAddress(request.Address, s.params.Prefix)
+	toAddress, err := util.DecodeAddress(address, s.params.Prefix)
 	if err != nil {
 		return nil, err
 	}
 
-	selectedUTXOs, changeSompi, err := s.selectUTXOs(request.Amount, feePerInput)
+	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)
 	if err != nil {
 		return nil, err
 	}
@@ -42,15 +62,19 @@ func (s *server) CreateUnsignedTransactions(_ context.Context, request *pb.Creat
 		return nil, err
 	}
 
-	unsignedTransaction, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
-		s.keysFile.MinimumSignatures,
-		[]*libkaspawallet.Payment{{
-			Address: toAddress,
-			Amount:  request.Amount,
-		}, {
+	payments := []*libkaspawallet.Payment{{
+		Address: toAddress,
+		Amount:  amount,
+	}}
+	if changeSompi > 0 {
+		payments = append(payments, &libkaspawallet.Payment{
 			Address: changeAddress,
 			Amount:  changeSompi,
-		}}, selectedUTXOs)
+		})
+	}
+	unsignedTransaction, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
+		s.keysFile.MinimumSignatures,
+		payments, selectedUTXOs)
 	if err != nil {
 		return nil, err
 	}
@@ -59,11 +83,10 @@ func (s *server) CreateUnsignedTransactions(_ context.Context, request *pb.Creat
 	if err != nil {
 		return nil, err
 	}
-
-	return &pb.CreateUnsignedTransactionsResponse{UnsignedTransactions: unsignedTransactions}, nil
+	return unsignedTransactions, nil
 }
 
-func (s *server) selectUTXOs(spendAmount uint64, feePerInput uint64) (
+func (s *server) selectUTXOs(spendAmount uint64, feePerInput uint64, fromAddresses []*walletAddress) (
 	selectedUTXOs []*libkaspawallet.UTXO, changeSompi uint64, err error) {
 
 	selectedUTXOs = []*libkaspawallet.UTXO{}
@@ -75,10 +98,19 @@ func (s *server) selectUTXOs(spendAmount uint64, feePerInput uint64) (
 	}
 
 	for _, utxo := range s.utxosSortedByAmount {
-		if !isUTXOSpendable(utxo, dagInfo.VirtualDAAScore, s.params.BlockCoinbaseMaturity) {
+		if (fromAddresses != nil && !slices.Contains(fromAddresses, utxo.address)) ||
+			!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

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

@@ -0,0 +1,29 @@
+package server
+
+import (
+	"context"
+
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
+)
+
+func (s *server) Send(_ context.Context, request *pb.SendRequest) (*pb.SendResponse, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	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

@@ -7,6 +7,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
 	"github.com/kaspanet/kaspad/util/txmass"
 
 	"github.com/kaspanet/kaspad/util/profiling"
@@ -35,6 +37,11 @@ type server struct {
 	shutdown            chan struct{}
 	addressSet          walletAddressSet
 	txMassCalculator    *txmass.Calculator
+	usedOutpoints       map[externalapi.DomainOutpoint]time.Time
+
+	isLogFinalProgressLineShown bool
+	maxUsedAddressesForLog      uint32
+	maxProcessedAddressesForLog uint32
 }
 
 // Start starts the kaspawalletd server
@@ -50,31 +57,38 @@ func Start(params *dagconfig.Params, listen, rpcServer string, keysFilePath stri
 
 	listener, err := net.Listen("tcp", listen)
 	if err != nil {
-		return (errors.Wrapf(err, "Error listening to tcp at %s", listen))
+		return (errors.Wrapf(err, "Error listening to TCP on %s", listen))
 	}
-	log.Infof("Listening on %s", listen)
+	log.Infof("Listening to TCP on %s", listen)
 
+	log.Infof("Connecting to a node at %s...", rpcServer)
 	rpcClient, err := connectToRPC(params, rpcServer)
 	if err != nil {
 		return (errors.Wrapf(err, "Error connecting to RPC server %s", rpcServer))
 	}
 
+	log.Infof("Connected, reading keys file %s...", keysFilePath)
 	keysFile, err := keys.ReadKeysFile(params, keysFilePath)
 	if err != nil {
-		return (errors.Wrapf(err, "Error connecting to RPC server %s", rpcServer))
+		return (errors.Wrapf(err, "Error reading keys file %s", keysFilePath))
 	}
 
 	serverInstance := &server{
-		rpcClient:           rpcClient,
-		params:              params,
-		utxosSortedByAmount: []*walletUTXO{},
-		nextSyncStartIndex:  0,
-		keysFile:            keysFile,
-		shutdown:            make(chan struct{}),
-		addressSet:          make(walletAddressSet),
-		txMassCalculator:    txmass.NewCalculator(params.MassPerTxByte, params.MassPerScriptPubKeyByte, params.MassPerSigOp),
+		rpcClient:                   rpcClient,
+		params:                      params,
+		utxosSortedByAmount:         []*walletUTXO{},
+		nextSyncStartIndex:          0,
+		keysFile:                    keysFile,
+		shutdown:                    make(chan struct{}),
+		addressSet:                  make(walletAddressSet),
+		txMassCalculator:            txmass.NewCalculator(params.MassPerTxByte, params.MassPerScriptPubKeyByte, params.MassPerSigOp),
+		usedOutpoints:               map[externalapi.DomainOutpoint]time.Time{},
+		isLogFinalProgressLineShown: false,
+		maxUsedAddressesForLog:      0,
+		maxProcessedAddressesForLog: 0,
 	}
 
+	log.Infof("Read, syncing the wallet...")
 	spawn("serverInstance.sync", func() {
 		err := serverInstance.sync()
 		if err != nil {

cmd/kaspawallet/daemon/server/sign.go

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

@@ -1,6 +1,7 @@
 package server
 
 import (
+	"fmt"
 	"sort"
 	"time"
 
@@ -26,19 +27,28 @@ func (s *server) sync() error {
 	ticker := time.NewTicker(time.Second)
 	defer ticker.Stop()
 
-	for range ticker.C {
-		err := s.collectRecentAddresses()
-		if err != nil {
-			return err
-		}
+	err := s.collectRecentAddresses()
+	if err != nil {
+		return err
+	}
 
+	err = s.refreshExistingUTXOsWithLock()
+	if err != nil {
+		return err
+	}
+
+	for range ticker.C {
 		err = s.collectFarAddresses()
 		if err != nil {
 			return err
 		}
 
-		err = s.refreshExistingUTXOsWithLock()
+		err = s.collectRecentAddresses()
+		if err != nil {
+			return err
+		}
 
+		err = s.refreshExistingUTXOsWithLock()
 		if err != nil {
 			return err
 		}
@@ -47,7 +57,10 @@ func (s *server) sync() error {
 	return nil
 }
 
-const numIndexesToQuery = 100
+const (
+	numIndexesToQueryForFarAddresses    = 100
+	numIndexesToQueryForRecentAddresses = 1000
+)
 
 // addressesToQuery scans the addresses in the given range. Because
 // each cosigner in a multisig has its own unique path for generating
@@ -75,24 +88,28 @@ func (s *server) addressesToQuery(start, end uint32) (walletAddressSet, error) {
 	return addresses, nil
 }
 
-// collectFarAddresses collects numIndexesToQuery addresses
+// collectFarAddresses collects numIndexesToQueryForFarAddresses 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+numIndexesToQuery)
+	err := s.collectAddresses(s.nextSyncStartIndex, s.nextSyncStartIndex+numIndexesToQueryForFarAddresses)
 	if err != nil {
 		return err
 	}
 
-	s.nextSyncStartIndex += numIndexesToQuery
+	s.nextSyncStartIndex += numIndexesToQueryForFarAddresses
 	return nil
 }
 
-func (s *server) maxUsedIndex() uint32 {
+func (s *server) maxUsedIndexWithLock() uint32 {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
 
+	return s.maxUsedIndex()
+}
+
+func (s *server) maxUsedIndex() uint32 {
 	maxUsedIndex := s.keysFile.LastUsedExternalIndex()
 	if s.keysFile.LastUsedInternalIndex() > maxUsedIndex {
 		maxUsedIndex = s.keysFile.LastUsedInternalIndex()
@@ -102,18 +119,29 @@ func (s *server) maxUsedIndex() uint32 {
 }
 
 // collectRecentAddresses collects addresses from used addresses until
-// the address with the index of the last used address + 1000.
-// collectRecentAddresses scans addresses in batches of numIndexesToQuery,
+// the address with the index of the last used address + numIndexesToQueryForRecentAddresses.
+// collectRecentAddresses scans addresses in batches of numIndexesToQueryForRecentAddresses,
 // and releases the lock between scans.
 func (s *server) collectRecentAddresses() error {
-	maxUsedIndex := s.maxUsedIndex()
-	for i := uint32(0); i < maxUsedIndex+1000; i += numIndexesToQuery {
-		err := s.collectAddressesWithLock(i, i+numIndexesToQuery)
+	index := uint32(0)
+	maxUsedIndex := uint32(0)
+	for ; index < maxUsedIndex+numIndexesToQueryForRecentAddresses; index += numIndexesToQueryForRecentAddresses {
+		err := s.collectAddressesWithLock(index, index+numIndexesToQueryForRecentAddresses)
+
 		if err != nil {
 			return err
 		}
+		maxUsedIndex = s.maxUsedIndexWithLock()
+
+		s.updateSyncingProgressLog(index, maxUsedIndex)
 	}
 
+	s.lock.Lock()
+	if index > s.nextSyncStartIndex {
+		s.nextSyncStartIndex = index
+	}
+	s.lock.Unlock()
+
 	return nil
 }
 
@@ -145,7 +173,6 @@ func (s *server) collectAddresses(start, end uint32) error {
 
 func (s *server) updateAddressesAndLastUsedIndexes(requestedAddressSet walletAddressSet,
 	getBalancesByAddressesResponse *appmessage.GetBalancesByAddressesResponseMessage) error {
-
 	lastUsedExternalIndex := s.keysFile.LastUsedExternalIndex()
 	lastUsedInternalIndex := s.keysFile.LastUsedInternalIndex()
 
@@ -159,10 +186,6 @@ func (s *server) updateAddressesAndLastUsedIndexes(requestedAddressSet walletAdd
 			continue
 		}
 
-		if walletAddress.cosignerIndex != s.keysFile.CosignerIndex {
-			continue
-		}
-
 		s.addressSet[entry.Address] = walletAddress
 
 		if walletAddress.keyChain == libkaspawallet.ExternalKeychain {
@@ -193,10 +216,23 @@ 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) error {
-	utxos := make([]*walletUTXO, len(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
+		}
 
-	for i, entry := range entries {
 		outpoint, err := appmessage.RPCOutpointToDomainOutpoint(entry.Outpoint)
 		if err != nil {
 			return err
@@ -211,11 +247,11 @@ func (s *server) updateUTXOSet(entries []*appmessage.UTXOsByAddressesEntry) erro
 		if !ok {
 			return errors.Errorf("Got result from address %s even though it wasn't requested", entry.Address)
 		}
-		utxos[i] = &walletUTXO{
+		utxos = append(utxos, &walletUTXO{
 			Outpoint:  outpoint,
 			UTXOEntry: utxoEntry,
 			address:   address,
-		}
+		})
 	}
 
 	sort.Slice(utxos, func(i, j int) bool { return utxos[i].UTXOEntry.Amount() > utxos[j].UTXOEntry.Amount() })
@@ -226,14 +262,62 @@ func (s *server) updateUTXOSet(entries []*appmessage.UTXOsByAddressesEntry) erro
 }
 
 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(), true, true)
+	if err != nil {
+		return err
+	}
+
 	getUTXOsByAddressesResponse, err := s.rpcClient.GetUTXOsByAddresses(s.addressSet.strings())
 	if err != nil {
 		return err
 	}
 
-	return s.updateUTXOSet(getUTXOsByAddressesResponse.Entries)
+	return s.updateUTXOSet(getUTXOsByAddressesResponse.Entries, mempoolEntriesByAddresses.Entries)
 }
 
 func (s *server) isSynced() bool {
-	return s.nextSyncStartIndex > s.keysFile.LastUsedInternalIndex() && s.nextSyncStartIndex > s.keysFile.LastUsedExternalIndex()
+	return s.nextSyncStartIndex > s.maxUsedIndex()
+}
+
+func (s *server) formatSyncStateReport() string {
+	maxUsedIndex := s.maxUsedIndex()
+
+	if s.nextSyncStartIndex > maxUsedIndex {
+		maxUsedIndex = s.nextSyncStartIndex
+	}
+
+	return fmt.Sprintf("scanned %d out of %d addresses (%.2f%%)",
+		s.nextSyncStartIndex, maxUsedIndex, float64(s.nextSyncStartIndex)*100.0/float64(maxUsedIndex))
+}
+
+func (s *server) updateSyncingProgressLog(currProcessedAddresses, currMaxUsedAddresses uint32) {
+	if currMaxUsedAddresses > s.maxUsedAddressesForLog {
+		s.maxUsedAddressesForLog = currMaxUsedAddresses
+		if s.isLogFinalProgressLineShown {
+			log.Infof("An additional set of previously used addresses found, processing...")
+			s.maxProcessedAddressesForLog = 0
+			s.isLogFinalProgressLineShown = false
+		}
+	}
+
+	if currProcessedAddresses > s.maxProcessedAddressesForLog {
+		s.maxProcessedAddressesForLog = currProcessedAddresses
+	}
+
+	if s.maxProcessedAddressesForLog >= s.maxUsedAddressesForLog {
+		if !s.isLogFinalProgressLineShown {
+			log.Infof("Wallet is synced, ready for queries")
+			s.isLogFinalProgressLineShown = true
+		}
+	} else {
+		percentProcessed := float64(s.maxProcessedAddressesForLog) / float64(s.maxUsedAddressesForLog) * 100.0
+
+		log.Infof("%d addresses of %d processed (%.2f%%)...",
+			s.maxProcessedAddressesForLog, s.maxUsedAddressesForLog, percentProcessed)
+	}
 }

cmd/kaspawallet/dump_unencrypted_data.go

@@ -3,10 +3,11 @@ 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"
 )
@@ -24,6 +25,9 @@ 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,12 +5,13 @@ 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.
@@ -52,8 +53,8 @@ func encryptedMnemonicExtendedPublicKeyPairs(params *dagconfig.Params, mnemonics
 	password := []byte(cmdLinePassword)
 	if len(password) == 0 {
 
-		password = getPassword("Enter password for the key file:")
-		confirmPassword := getPassword("Confirm password:")
+		password = []byte(GetPassword("Enter password for the key file:"))
+		confirmPassword := []byte(GetPassword("Confirm password:"))
 
 		if subtle.ConstantTimeCompare(password, confirmPassword) != 1 {
 			return nil, nil, errors.New("Passwords are not identical")
@@ -61,6 +62,8 @@ func encryptedMnemonicExtendedPublicKeyPairs(params *dagconfig.Params, mnemonics
 	}
 
 	encryptedPrivateKeys = make([]*EncryptedMnemonic, 0, len(mnemonics))
+	extendedPublicKeys = make([]string, 0, len(mnemonics))
+
 	for _, mnemonic := range mnemonics {
 		extendedPublicKey, err := libkaspawallet.MasterPublicKeyFromMnemonic(params, mnemonic, isMultisig)
 		if err != nil {

cmd/kaspawallet/keys/get_password.go

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

cmd/kaspawallet/keys/keys.go

@@ -206,16 +206,13 @@ 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(cmdLinePassword string) ([]string, error) {
-	password := []byte(cmdLinePassword)
-	if len(password) == 0 {
-		password = getPassword("Password:")
-	}
+func (d *File) DecryptMnemonics(password string) ([]string, error) {
+	passwordBytes := []byte(password)
 
 	var numThreads uint8
 	if len(d.EncryptedMnemonics) > 0 {
 		var err error
-		numThreads, err = d.numThreads(password)
+		numThreads, err = d.numThreads(passwordBytes)
 		if err != nil {
 			return nil, err
 		}
@@ -224,7 +221,7 @@ func (d *File) DecryptMnemonics(cmdLinePassword string) ([]string, error) {
 	privateKeys := make([]string, len(d.EncryptedMnemonics))
 	for i, encryptedPrivateKey := range d.EncryptedMnemonics {
 		var err error
-		privateKeys[i], err = decryptMnemonic(numThreads, encryptedPrivateKey, password)
+		privateKeys[i], err = decryptMnemonic(numThreads, encryptedPrivateKey, passwordBytes)
 		if err != nil {
 			return nil, err
 		}

cmd/kaspawallet/libkaspawallet/converters.go

@@ -0,0 +1,61 @@
+package libkaspawallet
+
+import (
+	"encoding/hex"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
+)
+
+//KaspawalletdUTXOsTolibkaspawalletUTXOs converts a  []*pb.UtxosByAddressesEntry to a []*libkaspawallet.UTXO
+func KaspawalletdUTXOsTolibkaspawalletUTXOs(kaspawalletdUtxoEntires []*pb.UtxosByAddressesEntry) ([]*UTXO, error) {
+	UTXOs := make([]*UTXO, len(kaspawalletdUtxoEntires))
+	for i, entry := range kaspawalletdUtxoEntires {
+		script, err := hex.DecodeString(entry.UtxoEntry.ScriptPublicKey.ScriptPublicKey)
+		if err != nil {
+			return nil, err
+		}
+		transactionID, err := transactionid.FromString(entry.Outpoint.TransactionId)
+		if err != nil {
+			return nil, err
+		}
+		UTXOs[i] = &UTXO{
+			UTXOEntry: utxo.NewUTXOEntry(
+				entry.UtxoEntry.Amount,
+				&externalapi.ScriptPublicKey{
+					Script:  script,
+					Version: uint16(entry.UtxoEntry.ScriptPublicKey.Version),
+				},
+				entry.UtxoEntry.IsCoinbase,
+				entry.UtxoEntry.BlockDaaScore,
+			),
+			Outpoint: &externalapi.DomainOutpoint{
+				TransactionID: *transactionID,
+				Index:         entry.Outpoint.Index,
+			},
+		}
+	}
+	return UTXOs, nil
+}
+
+// AppMessageUTXOToKaspawalletdUTXO converts an appmessage.UTXOsByAddressesEntry to a  pb.UtxosByAddressesEntry
+func AppMessageUTXOToKaspawalletdUTXO(appUTXOsByAddressesEntry *appmessage.UTXOsByAddressesEntry) *pb.UtxosByAddressesEntry {
+	return &pb.UtxosByAddressesEntry{
+		Outpoint: &pb.Outpoint{
+			TransactionId: appUTXOsByAddressesEntry.Outpoint.TransactionID,
+			Index:         appUTXOsByAddressesEntry.Outpoint.Index,
+		},
+		UtxoEntry: &pb.UtxoEntry{
+			Amount: appUTXOsByAddressesEntry.UTXOEntry.Amount,
+			ScriptPublicKey: &pb.ScriptPublicKey{
+				Version:         uint32(appUTXOsByAddressesEntry.UTXOEntry.ScriptPublicKey.Version),
+				ScriptPublicKey: appUTXOsByAddressesEntry.UTXOEntry.ScriptPublicKey.Script,
+			},
+			BlockDaaScore: appUTXOsByAddressesEntry.UTXOEntry.BlockDAAScore,
+			IsCoinbase:    appUTXOsByAddressesEntry.UTXOEntry.IsCoinbase,
+		},
+	}
+}

cmd/kaspawallet/libkaspawallet/serialization/protoserialization/wallet.pb.go

@@ -1,13 +1,12 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.25.0
-// 	protoc        v3.12.3
+// 	protoc-gen-go v1.28.0
+// 	protoc        v3.17.2
 // source: wallet.proto
 
 package protoserialization
 
 import (
-	proto "github.com/golang/protobuf/proto"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
@@ -21,10 +20,6 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
-// This is a compile-time assertion that a sufficiently up-to-date version
-// of the legacy proto package is being used.
-const _ = proto.ProtoPackageIsVersion4
-
 type PartiallySignedTransaction struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache

cmd/kaspawallet/libkaspawallet/serialization/serialization.go

@@ -3,11 +3,11 @@ package serialization
 import (
 	"math"
 
-	"github.com/golang/protobuf/proto"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet/serialization/protoserialization"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
 	"github.com/pkg/errors"
+	"google.golang.org/protobuf/proto"
 )
 
 // PartiallySignedTransaction is a type that is intended
@@ -88,6 +88,22 @@ func SerializePartiallySignedTransaction(partiallySignedTransaction *PartiallySi
 	return proto.Marshal(partiallySignedTransactionToProto(partiallySignedTransaction))
 }
 
+//DeserializeDomainTransaction Deserialize a Transaction to an *externalapi.DomainTransaction
+func DeserializeDomainTransaction(serializedTransactionMessage []byte) (*externalapi.DomainTransaction, error) {
+	protoTransactionMessage := &protoserialization.TransactionMessage{}
+	err := proto.Unmarshal(serializedTransactionMessage, protoTransactionMessage)
+	if err != nil {
+		return nil, err
+	}
+
+	return transactionFromProto(protoTransactionMessage)
+}
+
+// SerializeDomainTransaction Serialize a *externalapi.DomainTransaction
+func SerializeDomainTransaction(tx *externalapi.DomainTransaction) ([]byte, error) {
+	return proto.Marshal(transactionToProto(tx))
+}
+
 func partiallySignedTransactionFromProto(protoPartiallySignedTransaction *protoserialization.PartiallySignedTransaction) (*PartiallySignedTransaction, error) {
 	tx, err := transactionFromProto(protoPartiallySignedTransaction.Tx)
 	if err != nil {

cmd/kaspawallet/libkaspawallet/transaction_test.go

@@ -2,6 +2,7 @@ package libkaspawallet_test
 
 import (
 	"fmt"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
 	"strings"
 	"testing"
 
@@ -310,3 +311,208 @@ func TestP2PK(t *testing.T) {
 		})
 	})
 }
+
+func TestMaxSompi(t *testing.T) {
+	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
+		params := &consensusConfig.Params
+		cfg := *consensusConfig
+		cfg.BlockCoinbaseMaturity = 0
+		cfg.PreDeflationaryPhaseBaseSubsidy = 20e6 * constants.SompiPerKaspa
+		tc, teardown, err := consensus.NewFactory().NewTestConsensus(&cfg, "TestMaxSompi")
+		if err != nil {
+			t.Fatalf("Error setting up tc: %+v", err)
+		}
+		defer teardown(false)
+
+		const numKeys = 1
+		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(&cfg.Params, mnemonics[i], false)
+			if err != nil {
+				t.Fatalf("MasterPublicKeyFromMnemonic: %+v", err)
+			}
+		}
+
+		const minimumSignatures = 1
+		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,
+		}
+
+		fundingBlock1Hash, _, err := tc.AddBlock([]*externalapi.DomainHash{cfg.GenesisHash}, coinbaseData, nil)
+		if err != nil {
+			t.Fatalf("AddBlock: %+v", err)
+		}
+
+		fundingBlock2Hash, _, err := tc.AddBlock([]*externalapi.DomainHash{fundingBlock1Hash}, coinbaseData, nil)
+		if err != nil {
+			t.Fatalf("AddBlock: %+v", err)
+		}
+
+		fundingBlock3Hash, _, err := tc.AddBlock([]*externalapi.DomainHash{fundingBlock2Hash}, coinbaseData, nil)
+		if err != nil {
+			t.Fatalf("AddBlock: %+v", err)
+		}
+
+		fundingBlock4Hash, _, err := tc.AddBlock([]*externalapi.DomainHash{fundingBlock3Hash}, coinbaseData, nil)
+		if err != nil {
+			t.Fatalf("AddBlock: %+v", err)
+		}
+
+		fundingBlock2, err := tc.GetBlock(fundingBlock2Hash)
+		if err != nil {
+			t.Fatalf("GetBlock: %+v", err)
+		}
+
+		fundingBlock3, err := tc.GetBlock(fundingBlock3Hash)
+		if err != nil {
+			t.Fatalf("GetBlock: %+v", err)
+		}
+
+		fundingBlock4, err := tc.GetBlock(fundingBlock4Hash)
+		if err != nil {
+			t.Fatalf("GetBlock: %+v", err)
+		}
+
+		block1Hash, _, err := tc.AddBlock([]*externalapi.DomainHash{fundingBlock4Hash}, nil, nil)
+		if err != nil {
+			t.Fatalf("AddBlock: %+v", err)
+		}
+
+		block1, err := tc.GetBlock(block1Hash)
+		if err != nil {
+			t.Fatalf("GetBlock: %+v", err)
+		}
+
+		txOut1 := fundingBlock2.Transactions[0].Outputs[0]
+		txOut2 := fundingBlock3.Transactions[0].Outputs[0]
+		txOut3 := fundingBlock4.Transactions[0].Outputs[0]
+		txOut4 := block1.Transactions[0].Outputs[0]
+		selectedUTXOsForTxWithLargeInputAmount := []*libkaspawallet.UTXO{
+			{
+				Outpoint: &externalapi.DomainOutpoint{
+					TransactionID: *consensushashing.TransactionID(fundingBlock2.Transactions[0]),
+					Index:         0,
+				},
+				UTXOEntry:      utxo.NewUTXOEntry(txOut1.Value, txOut1.ScriptPublicKey, true, 0),
+				DerivationPath: path,
+			},
+			{
+				Outpoint: &externalapi.DomainOutpoint{
+					TransactionID: *consensushashing.TransactionID(fundingBlock3.Transactions[0]),
+					Index:         0,
+				},
+				UTXOEntry:      utxo.NewUTXOEntry(txOut2.Value, txOut2.ScriptPublicKey, true, 0),
+				DerivationPath: path,
+			},
+		}
+
+		unsignedTxWithLargeInputAmount, err := libkaspawallet.CreateUnsignedTransaction(publicKeys, minimumSignatures,
+			[]*libkaspawallet.Payment{{
+				Address: address,
+				Amount:  10,
+			}}, selectedUTXOsForTxWithLargeInputAmount)
+		if err != nil {
+			t.Fatalf("CreateUnsignedTransactions: %+v", err)
+		}
+
+		signedTxWithLargeInputAmount, err := libkaspawallet.Sign(params, mnemonics, unsignedTxWithLargeInputAmount, false)
+		if err != nil {
+			t.Fatalf("Sign: %+v", err)
+		}
+
+		txWithLargeInputAmount, err := libkaspawallet.ExtractTransaction(signedTxWithLargeInputAmount, false)
+		if err != nil {
+			t.Fatalf("ExtractTransaction: %+v", err)
+		}
+
+		_, virtualChangeSet, err := tc.AddBlock([]*externalapi.DomainHash{block1Hash}, nil, []*externalapi.DomainTransaction{txWithLargeInputAmount})
+		if err != nil {
+			t.Fatalf("AddBlock: %+v", err)
+		}
+
+		addedUTXO1 := &externalapi.DomainOutpoint{
+			TransactionID: *consensushashing.TransactionID(txWithLargeInputAmount),
+			Index:         0,
+		}
+		if !virtualChangeSet.VirtualUTXODiff.ToAdd().Contains(addedUTXO1) {
+			t.Fatalf("Transaction wasn't accepted in the DAG")
+		}
+
+		selectedUTXOsForTxWithLargeInputAndOutputAmount := []*libkaspawallet.UTXO{
+			{
+				Outpoint: &externalapi.DomainOutpoint{
+					TransactionID: *consensushashing.TransactionID(fundingBlock4.Transactions[0]),
+					Index:         0,
+				},
+				UTXOEntry:      utxo.NewUTXOEntry(txOut3.Value, txOut3.ScriptPublicKey, true, 0),
+				DerivationPath: path,
+			},
+			{
+				Outpoint: &externalapi.DomainOutpoint{
+					TransactionID: *consensushashing.TransactionID(block1.Transactions[0]),
+					Index:         0,
+				},
+				UTXOEntry:      utxo.NewUTXOEntry(txOut4.Value, txOut4.ScriptPublicKey, true, 0),
+				DerivationPath: path,
+			},
+		}
+
+		unsignedTxWithLargeInputAndOutputAmount, err := libkaspawallet.CreateUnsignedTransaction(publicKeys, minimumSignatures,
+			[]*libkaspawallet.Payment{{
+				Address: address,
+				Amount:  22e6 * constants.SompiPerKaspa,
+			}}, selectedUTXOsForTxWithLargeInputAndOutputAmount)
+		if err != nil {
+			t.Fatalf("CreateUnsignedTransactions: %+v", err)
+		}
+
+		signedTxWithLargeInputAndOutputAmount, err := libkaspawallet.Sign(params, mnemonics, unsignedTxWithLargeInputAndOutputAmount, false)
+		if err != nil {
+			t.Fatalf("Sign: %+v", err)
+		}
+
+		txWithLargeInputAndOutputAmount, err := libkaspawallet.ExtractTransaction(signedTxWithLargeInputAndOutputAmount, false)
+		if err != nil {
+			t.Fatalf("ExtractTransaction: %+v", err)
+		}
+
+		// We're creating a new longer chain so we can double spend txWithLargeInputAmount
+		newChainRoot, _, err := tc.AddBlock([]*externalapi.DomainHash{block1Hash}, nil, nil)
+		if err != nil {
+			t.Fatalf("AddBlock: %+v", err)
+		}
+
+		_, virtualChangeSet, err = tc.AddBlock([]*externalapi.DomainHash{newChainRoot}, nil, []*externalapi.DomainTransaction{txWithLargeInputAndOutputAmount})
+		if err != nil {
+			t.Fatalf("AddBlock: %+v", err)
+		}
+
+		addedUTXO2 := &externalapi.DomainOutpoint{
+			TransactionID: *consensushashing.TransactionID(txWithLargeInputAndOutputAmount),
+			Index:         0,
+		}
+
+		if !virtualChangeSet.VirtualUTXODiff.ToAdd().Contains(addedUTXO2) {
+			t.Fatalf("txWithLargeInputAndOutputAmount weren't accepted in the DAG")
+		}
+	})
+}

cmd/kaspawallet/main.go

@@ -29,6 +29,8 @@ func main() {
 		err = dumpUnencryptedData(config.(*dumpUnencryptedDataConfig))
 	case startDaemonSubCmd:
 		err = startDaemon(config.(*startDaemonConfig))
+	case sweepSubCmd:
+		err = sweep(config.(*sweepConfig))
 	default:
 		err = errors.Errorf("Unknown sub-command '%s'\n", subCmd)
 	}

cmd/kaspawallet/parse.go

@@ -29,55 +29,57 @@ func parse(conf *parseConfig) error {
 		transactionHex = strings.TrimSpace(string(transactionHexBytes))
 	}
 
-	transaction, err := hex.DecodeString(transactionHex)
+	transactions, err := decodeTransactionsFromHex(transactionHex)
 	if err != nil {
 		return err
 	}
+	for i, transaction := range transactions {
 
-	partiallySignedTransaction, err := serialization.DeserializePartiallySignedTransaction(transaction)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("Transaction ID: \t%s\n", consensushashing.TransactionID(partiallySignedTransaction.Tx))
-	fmt.Println()
-
-	allInputSompi := uint64(0)
-	for index, input := range partiallySignedTransaction.Tx.Inputs {
-		partiallySignedInput := partiallySignedTransaction.PartiallySignedInputs[index]
-
-		if conf.Verbose {
-			fmt.Printf("Input %d: \tOutpoint: %s:%d \tAmount: %.2f Kaspa\n", index, input.PreviousOutpoint.TransactionID,
-				input.PreviousOutpoint.Index, float64(partiallySignedInput.PrevOutput.Value)/float64(constants.SompiPerKaspa))
-		}
-
-		allInputSompi += partiallySignedInput.PrevOutput.Value
-	}
-	if conf.Verbose {
-		fmt.Println()
-	}
-
-	allOutputSompi := uint64(0)
-	for index, output := range partiallySignedTransaction.Tx.Outputs {
-		scriptPublicKeyType, scriptPublicKeyAddress, err := txscript.ExtractScriptPubKeyAddress(output.ScriptPublicKey, conf.ActiveNetParams)
+		partiallySignedTransaction, err := serialization.DeserializePartiallySignedTransaction(transaction)
 		if err != nil {
 			return err
 		}
 
-		addressString := scriptPublicKeyAddress.EncodeAddress()
-		if scriptPublicKeyType == txscript.NonStandardTy {
-			scriptPublicKeyHex := hex.EncodeToString(output.ScriptPublicKey.Script)
-			addressString = fmt.Sprintf("<Non-standard transaction script public key: %s>", scriptPublicKeyHex)
+		fmt.Printf("Transaction #%d ID: \t%s\n", i+1, consensushashing.TransactionID(partiallySignedTransaction.Tx))
+		fmt.Println()
+
+		allInputSompi := uint64(0)
+		for index, input := range partiallySignedTransaction.Tx.Inputs {
+			partiallySignedInput := partiallySignedTransaction.PartiallySignedInputs[index]
+
+			if conf.Verbose {
+				fmt.Printf("Input %d: \tOutpoint: %s:%d \tAmount: %.2f Kaspa\n", index, input.PreviousOutpoint.TransactionID,
+					input.PreviousOutpoint.Index, float64(partiallySignedInput.PrevOutput.Value)/float64(constants.SompiPerKaspa))
+			}
+
+			allInputSompi += partiallySignedInput.PrevOutput.Value
+		}
+		if conf.Verbose {
+			fmt.Println()
 		}
 
-		fmt.Printf("Output %d: \tRecipient: %s \tAmount: %.2f Kaspa\n",
-			index, addressString, float64(output.Value)/float64(constants.SompiPerKaspa))
+		allOutputSompi := uint64(0)
+		for index, output := range partiallySignedTransaction.Tx.Outputs {
+			scriptPublicKeyType, scriptPublicKeyAddress, err := txscript.ExtractScriptPubKeyAddress(output.ScriptPublicKey, conf.ActiveNetParams)
+			if err != nil {
+				return err
+			}
 
-		allOutputSompi += output.Value
+			addressString := scriptPublicKeyAddress.EncodeAddress()
+			if scriptPublicKeyType == txscript.NonStandardTy {
+				scriptPublicKeyHex := hex.EncodeToString(output.ScriptPublicKey.Script)
+				addressString = fmt.Sprintf("<Non-standard transaction script public key: %s>", scriptPublicKeyHex)
+			}
+
+			fmt.Printf("Output %d: \tRecipient: %s \tAmount: %.2f Kaspa\n",
+				index, addressString, float64(output.Value)/float64(constants.SompiPerKaspa))
+
+			allOutputSompi += output.Value
+		}
+		fmt.Println()
+
+		fmt.Printf("Fee:\t%d Sompi\n\n", allInputSompi-allOutputSompi)
 	}
-	fmt.Println()
-
-	fmt.Printf("Fee:\t%d Sompi\n", allInputSompi-allOutputSompi)
 
 	return nil
 }

cmd/kaspawallet/send.go

@@ -32,8 +32,10 @@ func send(conf *sendConfig) error {
 	defer cancel()
 
 	sendAmountSompi := uint64(conf.SendAmount * constants.SompiPerKaspa)
+
 	createUnsignedTransactionsResponse, err :=
 		daemonClient.CreateUnsignedTransactions(ctx, &pb.CreateUnsignedTransactionsRequest{
+			From:    conf.FromAddresses,
 			Address: conf.ToAddress,
 			Amount:  sendAmountSompi,
 		})
@@ -41,6 +43,9 @@ func send(conf *sendConfig) error {
 		return err
 	}
 
+	if len(conf.Password) == 0 {
+		conf.Password = keys.GetPassword("Password:")
+	}
 	mnemonics, err := keysFile.DecryptMnemonics(conf.Password)
 	if err != nil {
 		return err
@@ -58,24 +63,15 @@ func send(conf *sendConfig) error {
 	if len(signedTransactions) > 1 {
 		fmt.Printf("Broadcasting %d transactions\n", len(signedTransactions))
 	}
-	for _, signedTransaction := range signedTransactions {
-		err := func() error { // surround with func so that defer runs separately per transaction
-			ctx2, cancel2 := context.WithTimeout(context.Background(), daemonTimeout)
-			defer cancel2()
-			broadcastResponse, err := daemonClient.Broadcast(ctx2, &pb.BroadcastRequest{
-				Transaction: signedTransaction,
-			})
-			if err != nil {
-				return err
-			}
 
-			fmt.Println("Transaction was sent successfully")
-			fmt.Printf("Transaction ID: \t%s\n", broadcastResponse.TxID)
-			return nil
-		}()
-		if err != nil {
-			return err
-		}
+	response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{Transactions: signedTransactions})
+	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)
 	}
 
 	return nil

cmd/kaspawallet/sign.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"io/ioutil"
+	"os"
 	"strings"
 
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/keys"
@@ -22,6 +23,10 @@ func sign(conf *signConfig) error {
 	if err != nil {
 		return err
 	}
+
+	if len(conf.Password) == 0 {
+		conf.Password = keys.GetPassword("Password:")
+	}
 	privateKeys, err := keysFile.DecryptMnemonics(conf.Password)
 	if err != nil {
 		return err
@@ -62,12 +67,11 @@ func sign(conf *signConfig) error {
 	}
 
 	if areAllTransactionsFullySigned {
-		fmt.Println("The transaction is signed and ready to broadcast")
+		fmt.Fprintln(os.Stderr, "The transaction is signed and ready to broadcast")
 	} else {
-		fmt.Println("Successfully signed transaction")
+		fmt.Fprintln(os.Stderr, "Successfully signed transaction")
 	}
 
-	fmt.Println("Transaction: ")
 	fmt.Println(encodeTransactionsToHex(updatedPartiallySignedTransactions))
 	return nil
 }

cmd/kaspawallet/sweep.go

@@ -0,0 +1,242 @@
+package main
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/kaspanet/go-secp256k1"
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
+	"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/cmd/kaspawallet/utils"
+	"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/subnetworks"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
+	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/txmass"
+	"github.com/pkg/errors"
+)
+
+const feePerInput = 10000
+
+func sweep(conf *sweepConfig) error {
+
+	privateKeyBytes, err := hex.DecodeString(conf.PrivateKey)
+	if err != nil {
+		return err
+	}
+
+	publicKeybytes, err := libkaspawallet.PublicKeyFromPrivateKey(privateKeyBytes)
+	if err != nil {
+		return err
+	}
+
+	addressPubKey, err := util.NewAddressPublicKey(publicKeybytes, conf.NetParams().Prefix)
+	if err != nil {
+		return err
+	}
+
+	address, err := util.DecodeAddress(addressPubKey.String(), conf.NetParams().Prefix)
+	if err != nil {
+		return err
+	}
+
+	daemonClient, tearDown, err := client.Connect(conf.DaemonAddress)
+	if err != nil {
+		return err
+	}
+	defer tearDown()
+
+	ctx, cancel := context.WithTimeout(context.Background(), daemonTimeout)
+	defer cancel()
+
+	getExternalSpendableUTXOsResponse, err := daemonClient.GetExternalSpendableUTXOs(ctx, &pb.GetExternalSpendableUTXOsRequest{
+		Address: address.String(),
+	})
+	if err != nil {
+		return err
+	}
+
+	UTXOs, err := libkaspawallet.KaspawalletdUTXOsTolibkaspawalletUTXOs(getExternalSpendableUTXOsResponse.Entries)
+	if err != nil {
+		return err
+	}
+
+	paymentAmount := uint64(0)
+
+	if len(UTXOs) == 0 {
+		return errors.Errorf("Could not find any spendable UTXOs in %s", addressPubKey)
+	}
+
+	for _, UTXO := range UTXOs {
+		paymentAmount = paymentAmount + UTXO.UTXOEntry.Amount()
+	}
+
+	newAddressResponse, err := daemonClient.NewAddress(ctx, &pb.NewAddressRequest{})
+	if err != nil {
+		return err
+	}
+
+	toAddress, err := util.DecodeAddress(newAddressResponse.Address, conf.ActiveNetParams.Prefix)
+	if err != nil {
+		return err
+	}
+
+	splitTransactions, err := createSplitTransactionsWithSchnorrPrivteKey(conf.NetParams(), UTXOs, toAddress, feePerInput)
+	if err != nil {
+		return err
+	}
+
+	serializedSplitTransactions, err := signWithSchnorrPrivateKey(conf.NetParams(), privateKeyBytes, splitTransactions)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println("\nSweeping...")
+	fmt.Println("\tFrom:\t", addressPubKey)
+	fmt.Println("\tTo:\t", toAddress)
+
+	response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{
+		IsDomain:     true,
+		Transactions: serializedSplitTransactions,
+	})
+	if err != nil {
+		return err
+	}
+
+	totalExtracted := uint64(0)
+
+	fmt.Println("\nTransaction ID(s):")
+	for i, txID := range response.TxIDs {
+		fmt.Printf("\t%s\n", txID)
+		fmt.Println("\tSwept:\t", utils.FormatKas(splitTransactions[i].Outputs[0].Value), " KAS")
+		totalExtracted = totalExtracted + splitTransactions[i].Outputs[0].Value
+	}
+
+	fmt.Println("\nTotal Funds swept (including transaction fees):")
+	fmt.Println("\t", utils.FormatKas(totalExtracted), " KAS")
+
+	return nil
+}
+
+func newDummyTransaction() *externalapi.DomainTransaction {
+	return &externalapi.DomainTransaction{
+		Version:      constants.MaxTransactionVersion,
+		Inputs:       make([]*externalapi.DomainTransactionInput, 0), //we create empty inputs
+		LockTime:     0,
+		Outputs:      make([]*externalapi.DomainTransactionOutput, 1), // we should always have 1 output to the toAdress
+		SubnetworkID: subnetworks.SubnetworkIDNative,
+		Gas:          0,
+		Payload:      nil,
+	}
+}
+
+func createSplitTransactionsWithSchnorrPrivteKey(
+	params *dagconfig.Params,
+	selectedUTXOs []*libkaspawallet.UTXO,
+	toAddress util.Address,
+	feePerInput int) ([]*externalapi.DomainTransaction, error) {
+
+	var splitTransactions []*externalapi.DomainTransaction
+
+	extraMass := uint64(7000) // Account for future signatures.
+
+	massCalculater := txmass.NewCalculator(params.MassPerTxByte, params.MassPerScriptPubKeyByte, params.MassPerSigOp)
+
+	scriptPublicKey, err := txscript.PayToAddrScript(toAddress)
+	if err != nil {
+		return nil, err
+	}
+
+	totalSplitAmount := uint64(0)
+
+	lastValidTx := newDummyTransaction()
+	currentTx := newDummyTransaction() //i.e. the tested tx
+
+	//loop through utxos commit segments that don't violate max mass
+	for i, currentUTXO := range selectedUTXOs {
+
+		totalSplitAmount = totalSplitAmount + currentUTXO.UTXOEntry.Amount()
+
+		currentTx.Inputs = append(
+			currentTx.Inputs,
+			&externalapi.DomainTransactionInput{
+				PreviousOutpoint: *currentUTXO.Outpoint,
+				UTXOEntry: utxo.NewUTXOEntry(
+					currentUTXO.UTXOEntry.Amount(),
+					currentUTXO.UTXOEntry.ScriptPublicKey(),
+					false,
+					constants.UnacceptedDAAScore,
+				),
+				SigOpCount: 1,
+			},
+		)
+
+		currentTx.Outputs[0] = &externalapi.DomainTransactionOutput{
+			Value:           totalSplitAmount - uint64(len(currentTx.Inputs)*feePerInput),
+			ScriptPublicKey: scriptPublicKey,
+		}
+
+		if massCalculater.CalculateTransactionMass(currentTx)+extraMass >= mempool.MaximumStandardTransactionMass {
+
+			//in this loop we assume a transaction with one input and one output cannot violate max transaction mass, hence a sanity check.
+			if len(currentTx.Inputs) == 1 {
+				return nil, errors.Errorf("transaction with one input and one output violates transaction mass")
+			}
+
+			splitTransactions = append(splitTransactions, lastValidTx)
+			totalSplitAmount = 0
+			lastValidTx = newDummyTransaction()
+			currentTx = newDummyTransaction()
+			continue
+		}
+
+		//Special case, end of inputs, with no violation, where we can assign currentTX to split and break
+		if i == len(selectedUTXOs)-1 {
+			splitTransactions = append(splitTransactions, currentTx)
+			break
+
+		}
+
+		lastValidTx = currentTx.Clone()
+		currentTx.Outputs = make([]*externalapi.DomainTransactionOutput, 1)
+
+	}
+	return splitTransactions, nil
+}
+
+func signWithSchnorrPrivateKey(params *dagconfig.Params, privateKeyBytes []byte, domainTransactions []*externalapi.DomainTransaction) ([][]byte, error) {
+
+	schnorrkeyPair, err := secp256k1.DeserializeSchnorrPrivateKeyFromSlice(privateKeyBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	serializedDomainTransactions := make([][]byte, len(domainTransactions))
+
+	for i1, domainTransaction := range domainTransactions {
+
+		sighashReusedValues := &consensushashing.SighashReusedValues{}
+
+		for i2, input := range domainTransaction.Inputs {
+			signature, err := txscript.SignatureScript(domainTransaction, i2, consensushashing.SigHashAll, schnorrkeyPair, sighashReusedValues)
+			if err != nil {
+				return nil, err
+			}
+			input.SignatureScript = signature
+		}
+		serializedDomainTransactions[i1], err = serialization.SerializeDomainTransaction(domainTransaction)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return serializedDomainTransactions, nil
+}

cmd/kaspawallet/utils/format_kas.go

@@ -0,0 +1,16 @@
+package utils
+
+import (
+	"fmt"
+
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
+)
+
+// FormatKas takes the amount of sompis as uint64, and returns amount of KAS with 8  decimal places
+func FormatKas(amount uint64) string {
+	res := "                   "
+	if amount > 0 {
+		res = fmt.Sprintf("%19.8f", float64(amount)/constants.SompiPerKaspa)
+	}
+	return res
+}

docker/Dockerfile

@@ -6,15 +6,16 @@ RUN mkdir -p /go/src/github.com/kaspanet/kaspad
 WORKDIR /go/src/github.com/kaspanet/kaspad
 
 RUN apk add --no-cache curl git openssh binutils gcc musl-dev
+
+COPY go.mod .
+COPY go.sum .
+
 RUN go get -u golang.org/x/lint/golint \
       github.com/kisielk/errcheck \
       github.com/opennota/check/cmd/aligncheck \
       github.com/opennota/check/cmd/structcheck \
       github.com/opennota/check/cmd/varcheck \
-      honnef.co/go/tools/cmd/staticcheck 
-
-COPY go.mod .
-COPY go.sum .
+      honnef.co/go/tools/cmd/staticcheck
 
 # Cache kaspad dependencies
 RUN go mod download

domain/consensus/consensus.go

@@ -4,6 +4,8 @@ import (
 	"math/big"
 	"sync"
 
+	"github.com/kaspanet/kaspad/util/mstime"
+
 	"github.com/kaspanet/kaspad/domain/consensus/database"
 	"github.com/kaspanet/kaspad/domain/consensus/model"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@@ -20,6 +22,8 @@ type consensus struct {
 	genesisBlock *externalapi.DomainBlock
 	genesisHash  *externalapi.DomainHash
 
+	expectedDAAWindowDurationInMilliseconds int64
+
 	blockProcessor        model.BlockProcessor
 	blockBuilder          model.BlockBuilder
 	consensusStateManager model.ConsensusStateManager
@@ -55,13 +59,20 @@ type consensus struct {
 	headersSelectedChainStore           model.HeadersSelectedChainStore
 	daaBlocksStore                      model.DAABlocksStore
 	blocksWithTrustedDataDAAWindowStore model.BlocksWithTrustedDataDAAWindowStore
+
+	consensusEventsChan chan externalapi.ConsensusEvent
+	virtualNotUpdated   bool
 }
 
-func (s *consensus) ValidateAndInsertBlockWithTrustedData(block *externalapi.BlockWithTrustedData, validateUTXO bool) (*externalapi.VirtualChangeSet, error) {
+func (s *consensus) ValidateAndInsertBlockWithTrustedData(block *externalapi.BlockWithTrustedData, validateUTXO bool) error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	return s.blockProcessor.ValidateAndInsertBlockWithTrustedData(block, validateUTXO)
+	_, _, err := s.blockProcessor.ValidateAndInsertBlockWithTrustedData(block, validateUTXO)
+	if err != nil {
+		return err
+	}
+	return nil
 }
 
 // Init initializes consensus
@@ -126,7 +137,7 @@ func (s *consensus) Init(skipAddingGenesis bool) error {
 				},
 			},
 		}
-		_, err = s.blockProcessor.ValidateAndInsertBlockWithTrustedData(genesisWithTrustedData, true)
+		_, _, err = s.blockProcessor.ValidateAndInsertBlockWithTrustedData(genesisWithTrustedData, true)
 		if err != nil {
 			return err
 		}
@@ -154,24 +165,128 @@ func (s *consensus) BuildBlock(coinbaseData *externalapi.DomainCoinbaseData,
 	return block, err
 }
 
-// BuildBlockWithTemplateMetadata builds a block over the current state, with the transactions
-// selected by the given transactionSelector plus metadata information related to coinbase rewards
-func (s *consensus) BuildBlockWithTemplateMetadata(coinbaseData *externalapi.DomainCoinbaseData,
-	transactions []*externalapi.DomainTransaction) (block *externalapi.DomainBlock, coinbaseHasRedReward bool, err error) {
+// BuildBlockTemplate builds a block over the current state, with the transactions
+// selected by the given transactionSelector plus metadata information related to
+// coinbase rewards and node sync status
+func (s *consensus) BuildBlockTemplate(coinbaseData *externalapi.DomainCoinbaseData,
+	transactions []*externalapi.DomainTransaction) (*externalapi.DomainBlockTemplate, error) {
 
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	return s.blockBuilder.BuildBlock(coinbaseData, transactions)
+	block, hasRedReward, err := s.blockBuilder.BuildBlock(coinbaseData, transactions)
+	if err != nil {
+		return nil, err
+	}
+
+	isNearlySynced, err := s.isNearlySyncedNoLock()
+	if err != nil {
+		return nil, err
+	}
+
+	return &externalapi.DomainBlockTemplate{
+		Block:                block,
+		CoinbaseData:         coinbaseData,
+		CoinbaseHasRedReward: hasRedReward,
+		IsNearlySynced:       isNearlySynced,
+	}, nil
 }
 
 // ValidateAndInsertBlock validates the given block and, if valid, applies it
 // to the current state
-func (s *consensus) ValidateAndInsertBlock(block *externalapi.DomainBlock, shouldValidateAgainstUTXO bool) (*externalapi.VirtualChangeSet, error) {
+func (s *consensus) ValidateAndInsertBlock(block *externalapi.DomainBlock, shouldValidateAgainstUTXO bool) error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	return s.blockProcessor.ValidateAndInsertBlock(block, shouldValidateAgainstUTXO)
+	_, err := s.validateAndInsertBlockNoLock(block, shouldValidateAgainstUTXO)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *consensus) validateAndInsertBlockNoLock(block *externalapi.DomainBlock, updateVirtual bool) (*externalapi.VirtualChangeSet, error) {
+	// If virtual is in non-updated state, and the caller requests updating virtual -- then we must first
+	// resolve virtual so that the new block can be fully processed properly
+	if updateVirtual && s.virtualNotUpdated {
+		for s.virtualNotUpdated {
+			// We use 10000 << finality interval. See comment in `ResolveVirtual`.
+			// We give up responsiveness of consensus in this rare case.
+			_, err := s.resolveVirtualNoLock(10000) // Note `s.virtualNotUpdated` is updated within the call
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	virtualChangeSet, blockStatus, err := s.blockProcessor.ValidateAndInsertBlock(block, updateVirtual)
+	if err != nil {
+		return nil, err
+	}
+
+	// If block has a body, and yet virtual was not updated -- signify that virtual is in non-updated state
+	if !updateVirtual && blockStatus != externalapi.StatusHeaderOnly {
+		s.virtualNotUpdated = true
+	}
+
+	err = s.sendBlockAddedEvent(block, blockStatus)
+	if err != nil {
+		return nil, err
+	}
+
+	err = s.sendVirtualChangedEvent(virtualChangeSet, updateVirtual)
+	if err != nil {
+		return nil, err
+	}
+
+	return virtualChangeSet, nil
+}
+
+func (s *consensus) sendBlockAddedEvent(block *externalapi.DomainBlock, blockStatus externalapi.BlockStatus) error {
+	if s.consensusEventsChan != nil {
+		if blockStatus == externalapi.StatusHeaderOnly || blockStatus == externalapi.StatusInvalid {
+			return nil
+		}
+
+		if len(s.consensusEventsChan) == cap(s.consensusEventsChan) {
+			return errors.Errorf("consensusEventsChan is full")
+		}
+		s.consensusEventsChan <- &externalapi.BlockAdded{Block: block}
+	}
+	return nil
+}
+
+func (s *consensus) sendVirtualChangedEvent(virtualChangeSet *externalapi.VirtualChangeSet, wasVirtualUpdated bool) error {
+	if !wasVirtualUpdated || s.consensusEventsChan == nil {
+		return nil
+	}
+
+	if len(s.consensusEventsChan) == cap(s.consensusEventsChan) {
+		return errors.Errorf("consensusEventsChan is full")
+	}
+
+	stagingArea := model.NewStagingArea()
+	virtualGHOSTDAGData, err := s.ghostdagDataStores[0].Get(s.databaseContext, stagingArea, model.VirtualBlockHash, false)
+	if err != nil {
+		return err
+	}
+
+	virtualSelectedParentGHOSTDAGData, err := s.ghostdagDataStores[0].Get(s.databaseContext, stagingArea, virtualGHOSTDAGData.SelectedParent(), false)
+	if err != nil {
+		return err
+	}
+
+	virtualDAAScore, err := s.daaBlocksStore.DAAScore(s.databaseContext, stagingArea, model.VirtualBlockHash)
+	if err != nil {
+		return err
+	}
+
+	// Populate the change set with additional data before sending
+	virtualChangeSet.VirtualSelectedParentBlueScore = virtualSelectedParentGHOSTDAGData.BlueScore()
+	virtualChangeSet.VirtualDAAScore = virtualDAAScore
+
+	s.consensusEventsChan <- virtualChangeSet
+	return nil
 }
 
 // ValidateTransactionAndPopulateWithConsensusData validates the given transaction
@@ -182,7 +297,12 @@ func (s *consensus) ValidateTransactionAndPopulateWithConsensusData(transaction
 
 	stagingArea := model.NewStagingArea()
 
-	err := s.transactionValidator.ValidateTransactionInIsolation(transaction)
+	daaScore, err := s.daaBlocksStore.DAAScore(s.databaseContext, stagingArea, model.VirtualBlockHash)
+	if err != nil {
+		return err
+	}
+
+	err = s.transactionValidator.ValidateTransactionInIsolation(transaction, daaScore)
 	if err != nil {
 		return err
 	}
@@ -333,6 +453,30 @@ func (s *consensus) GetBlockAcceptanceData(blockHash *externalapi.DomainHash) (e
 	return s.acceptanceDataStore.Get(s.databaseContext, stagingArea, blockHash)
 }
 
+func (s *consensus) GetBlocksAcceptanceData(blockHashes []*externalapi.DomainHash) ([]externalapi.AcceptanceData, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	stagingArea := model.NewStagingArea()
+	blocksAcceptanceData := make([]externalapi.AcceptanceData, len(blockHashes))
+
+	for i, blockHash := range blockHashes {
+		err := s.validateBlockHashExists(stagingArea, blockHash)
+		if err != nil {
+			return nil, err
+		}
+
+		acceptanceData, err := s.acceptanceDataStore.Get(s.databaseContext, stagingArea, blockHash)
+		if err != nil {
+			return nil, err
+		}
+
+		blocksAcceptanceData[i] = acceptanceData
+	}
+
+	return blocksAcceptanceData, nil
+}
+
 func (s *consensus) GetHashesBetween(lowHash, highHash *externalapi.DomainHash, maxBlocks uint64) (
 	hashes []*externalapi.DomainHash, actualHighHash *externalapi.DomainHash, err error) {
 
@@ -744,7 +888,7 @@ func (s *consensus) PopulateMass(transaction *externalapi.DomainTransaction) {
 	s.transactionValidator.PopulateMass(transaction)
 }
 
-func (s *consensus) ResolveVirtual() (*externalapi.VirtualChangeSet, bool, error) {
+func (s *consensus) ResolveVirtual() (bool, error) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
@@ -752,23 +896,33 @@ func (s *consensus) ResolveVirtual() (*externalapi.VirtualChangeSet, bool, error
 	// release the lock each time resolve 100 blocks.
 	// Note: maxBlocksToResolve should be smaller than finality interval in order to avoid a situation
 	// where UpdatePruningPointByVirtual skips a pruning point.
-	virtualChangeSet, isCompletelyResolved, err := s.consensusStateManager.ResolveVirtual(100)
+	return s.resolveVirtualNoLock(100)
+}
+
+func (s *consensus) resolveVirtualNoLock(maxBlocksToResolve uint64) (bool, error) {
+	virtualChangeSet, isCompletelyResolved, err := s.consensusStateManager.ResolveVirtual(maxBlocksToResolve)
 	if err != nil {
-		return nil, false, err
+		return false, err
 	}
+	s.virtualNotUpdated = !isCompletelyResolved
 
 	stagingArea := model.NewStagingArea()
 	err = s.pruningManager.UpdatePruningPointByVirtual(stagingArea)
 	if err != nil {
-		return nil, false, err
+		return false, err
 	}
 
 	err = staging.CommitAllChanges(s.databaseContext, stagingArea)
 	if err != nil {
-		return nil, false, err
+		return false, err
 	}
 
-	return virtualChangeSet, isCompletelyResolved, nil
+	err = s.sendVirtualChangedEvent(virtualChangeSet, true)
+	if err != nil {
+		return false, err
+	}
+
+	return isCompletelyResolved, nil
 }
 
 func (s *consensus) BuildPruningPointProof() (*externalapi.PruningPointProof, error) {
@@ -881,3 +1035,50 @@ func (s *consensus) IsChainBlock(blockHash *externalapi.DomainHash) (bool, error
 
 	return s.dagTopologyManagers[0].IsInSelectedParentChainOf(stagingArea, blockHash, virtualGHOSTDAGData.SelectedParent())
 }
+
+func (s *consensus) VirtualMergeDepthRoot() (*externalapi.DomainHash, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	stagingArea := model.NewStagingArea()
+	return s.mergeDepthManager.VirtualMergeDepthRoot(stagingArea)
+}
+
+// IsNearlySynced returns whether this consensus is considered synced or close to being synced. This info
+// is used to determine if it's ok to use a block template from this node for mining purposes.
+func (s *consensus) IsNearlySynced() (bool, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	return s.isNearlySyncedNoLock()
+}
+
+func (s *consensus) isNearlySyncedNoLock() (bool, error) {
+	stagingArea := model.NewStagingArea()
+	virtualGHOSTDAGData, err := s.ghostdagDataStores[0].Get(s.databaseContext, stagingArea, model.VirtualBlockHash, false)
+	if err != nil {
+		return false, err
+	}
+
+	if virtualGHOSTDAGData.SelectedParent().Equal(s.genesisHash) {
+		return false, nil
+	}
+
+	virtualSelectedParentHeader, err := s.blockHeaderStore.BlockHeader(s.databaseContext, stagingArea, virtualGHOSTDAGData.SelectedParent())
+	if err != nil {
+		return false, err
+	}
+
+	now := mstime.Now().UnixMilliseconds()
+	// As a heuristic, we allow the node to mine if he is likely to be within the current DAA window of fully synced nodes.
+	// Such blocks contribute to security by maintaining the current difficulty despite possibly being slightly out of sync.
+	if now-virtualSelectedParentHeader.TimeInMilliseconds() < s.expectedDAAWindowDurationInMilliseconds {
+		log.Debugf("The selected tip timestamp is recent (%d), so IsNearlySynced returns true",
+			virtualSelectedParentHeader.TimeInMilliseconds())
+		return true, nil
+	}
+
+	log.Debugf("The selected tip timestamp is old (%d), so IsNearlySynced returns false",
+		virtualSelectedParentHeader.TimeInMilliseconds())
+	return false, nil
+}

domain/consensus/consensus_test.go

@@ -27,7 +27,7 @@ func TestConsensus_GetBlockInfo(t *testing.T) {
 		newHeader := invalidBlock.Header.ToMutable()
 		newHeader.SetTimeInMilliseconds(0)
 		invalidBlock.Header = newHeader.ToImmutable()
-		_, err = consensus.ValidateAndInsertBlock(invalidBlock, true)
+		err = consensus.ValidateAndInsertBlock(invalidBlock, true)
 		if !errors.Is(err, ruleerrors.ErrTimeTooOld) {
 			t.Fatalf("Expected block to be invalid with err: %v, instead found: %v", ruleerrors.ErrTimeTooOld, err)
 		}
@@ -55,7 +55,7 @@ func TestConsensus_GetBlockInfo(t *testing.T) {
 			t.Fatalf("consensus.BuildBlock with an empty coinbase shouldn't fail: %v", err)
 		}
 
-		_, err = consensus.ValidateAndInsertBlock(validBlock, true)
+		err = consensus.ValidateAndInsertBlock(validBlock, true)
 		if err != nil {
 			t.Fatalf("consensus.ValidateAndInsertBlock with a block straight from consensus.BuildBlock should not fail: %v", err)
 		}

domain/consensus/database/serialization/dbobjects.pb.go

@@ -1,13 +1,12 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.25.0
-// 	protoc        v3.12.3
+// 	protoc-gen-go v1.28.0
+// 	protoc        v3.17.2
 // source: dbobjects.proto
 
 package serialization
 
 import (
-	proto "github.com/golang/protobuf/proto"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
@@ -21,10 +20,6 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
-// This is a compile-time assertion that a sufficiently up-to-date version
-// of the legacy proto package is being used.
-const _ = proto.ProtoPackageIsVersion4
-
 type DbBlock struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache

domain/consensus/datastructures/mergedepthrootstore/merge_depth_root_staging_shard.go

@@ -0,0 +1,36 @@
+package mergedepthrootstore
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+type mergeDepthRootStagingShard struct {
+	store *mergeDepthRootStore
+	toAdd map[externalapi.DomainHash]*externalapi.DomainHash
+}
+
+func (mdrs *mergeDepthRootStore) stagingShard(stagingArea *model.StagingArea) *mergeDepthRootStagingShard {
+	return stagingArea.GetOrCreateShard(mdrs.shardID, func() model.StagingShard {
+		return &mergeDepthRootStagingShard{
+			store: mdrs,
+			toAdd: make(map[externalapi.DomainHash]*externalapi.DomainHash),
+		}
+	}).(*mergeDepthRootStagingShard)
+}
+
+func (mdrss *mergeDepthRootStagingShard) Commit(dbTx model.DBTransaction) error {
+	for hash, mergeDepthRoot := range mdrss.toAdd {
+		err := dbTx.Put(mdrss.store.hashAsKey(&hash), mergeDepthRoot.ByteSlice())
+		if err != nil {
+			return err
+		}
+		mdrss.store.cache.Add(&hash, mergeDepthRoot)
+	}
+
+	return nil
+}
+
+func (mdrss *mergeDepthRootStagingShard) isStaged() bool {
+	return len(mdrss.toAdd) == 0
+}

domain/consensus/datastructures/mergedepthrootstore/merge_depth_root_store.go

@@ -0,0 +1,63 @@
+package mergedepthrootstore
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/lrucache"
+	"github.com/kaspanet/kaspad/util/staging"
+)
+
+var bucketName = []byte("merge-depth-roots")
+
+type mergeDepthRootStore struct {
+	shardID model.StagingShardID
+	cache   *lrucache.LRUCache
+	bucket  model.DBBucket
+}
+
+// New instantiates a new MergeDepthRootStore
+func New(prefixBucket model.DBBucket, cacheSize int, preallocate bool) model.MergeDepthRootStore {
+	return &mergeDepthRootStore{
+		shardID: staging.GenerateShardingID(),
+		cache:   lrucache.New(cacheSize, preallocate),
+		bucket:  prefixBucket.Bucket(bucketName),
+	}
+}
+
+func (mdrs *mergeDepthRootStore) StageMergeDepthRoot(stagingArea *model.StagingArea, blockHash *externalapi.DomainHash, root *externalapi.DomainHash) {
+	stagingShard := mdrs.stagingShard(stagingArea)
+
+	stagingShard.toAdd[*blockHash] = root
+}
+
+func (mdrs *mergeDepthRootStore) MergeDepthRoot(dbContext model.DBReader, stagingArea *model.StagingArea, blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error) {
+	stagingShard := mdrs.stagingShard(stagingArea)
+
+	if root, ok := stagingShard.toAdd[*blockHash]; ok {
+		return root, nil
+	}
+
+	if root, ok := mdrs.cache.Get(blockHash); ok {
+		return root.(*externalapi.DomainHash), nil
+	}
+
+	rootBytes, err := dbContext.Get(mdrs.hashAsKey(blockHash))
+	if err != nil {
+		return nil, err
+	}
+	root, err := externalapi.NewDomainHashFromByteSlice(rootBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	mdrs.cache.Add(blockHash, root)
+	return root, nil
+}
+
+func (mdrs *mergeDepthRootStore) IsStaged(stagingArea *model.StagingArea) bool {
+	return mdrs.stagingShard(stagingArea).isStaged()
+}
+
+func (mdrs *mergeDepthRootStore) hashAsKey(hash *externalapi.DomainHash) model.DBKey {
+	return mdrs.bucket.Key(hash.ByteSlice())
+}

domain/consensus/factory.go

@@ -1,17 +1,19 @@
 package consensus
 
 import (
+	"io/ioutil"
+	"os"
+	"sync"
+
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/blockwindowheapslicestore"
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/daawindowstore"
+	"github.com/kaspanet/kaspad/domain/consensus/datastructures/mergedepthrootstore"
 	"github.com/kaspanet/kaspad/domain/consensus/model"
 	"github.com/kaspanet/kaspad/domain/consensus/processes/blockparentbuilder"
 	parentssanager "github.com/kaspanet/kaspad/domain/consensus/processes/parentsmanager"
 	"github.com/kaspanet/kaspad/domain/consensus/processes/pruningproofmanager"
 	"github.com/kaspanet/kaspad/util/staging"
 	"github.com/pkg/errors"
-	"io/ioutil"
-	"os"
-	"sync"
 
 	"github.com/kaspanet/kaspad/domain/prefixmanager/prefix"
 	"github.com/kaspanet/kaspad/util/txmass"
@@ -75,7 +77,8 @@ type Config struct {
 
 // Factory instantiates new Consensuses
 type Factory interface {
-	NewConsensus(config *Config, db infrastructuredatabase.Database, dbPrefix *prefix.Prefix) (
+	NewConsensus(config *Config, db infrastructuredatabase.Database, dbPrefix *prefix.Prefix,
+		consensusEventsChan chan externalapi.ConsensusEvent) (
 		externalapi.Consensus, bool, error)
 	NewTestConsensus(config *Config, testName string) (
 		tc testapi.TestConsensus, teardown func(keepDataDir bool), err error)
@@ -107,7 +110,8 @@ func NewFactory() Factory {
 }
 
 // NewConsensus instantiates a new Consensus
-func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Database, dbPrefix *prefix.Prefix) (
+func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Database, dbPrefix *prefix.Prefix,
+	consensusEventsChan chan externalapi.ConsensusEvent) (
 	consensusInstance externalapi.Consensus, shouldMigrate bool, err error) {
 
 	dbManager := consensusdatabase.New(db)
@@ -127,6 +131,7 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 	pruningWindowSizePlusFinalityDepthForCache := int(config.PruningDepth() + config.FinalityDepth())
 
 	// Data Structures
+	mergeDepthRootStore := mergedepthrootstore.New(prefixBucket, 200, preallocateCaches)
 	daaWindowStore := daawindowstore.New(prefixBucket, 10_000, preallocateCaches)
 	acceptanceDataStore := acceptancedatastore.New(prefixBucket, 200, preallocateCaches)
 	blockStore, err := blockstore.New(dbManager, prefixBucket, 200, preallocateCaches)
@@ -261,7 +266,13 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		dagTopologyManager,
 		dagTraversalManager,
 		finalityManager,
-		ghostdagDataStore)
+		genesisHash,
+		config.MergeDepth,
+		ghostdagDataStore,
+		mergeDepthRootStore,
+		daaBlocksStore,
+		pruningStore,
+		finalityStore)
 	consensusStateManager, err := consensusstatemanager.New(
 		dbManager,
 		config.MaxBlockParents,
@@ -334,7 +345,6 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		config.MaxBlockParents,
 		config.TimestampDeviationTolerance,
 		config.TargetTimePerBlock,
-		config.IgnoreHeaderMass,
 		config.MaxBlockLevel,
 
 		dbManager,
@@ -465,6 +475,9 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		genesisBlock: config.GenesisBlock,
 		genesisHash:  config.GenesisHash,
 
+		expectedDAAWindowDurationInMilliseconds: config.TargetTimePerBlock.Milliseconds() *
+			int64(config.DifficultyAdjustmentWindowSize),
+
 		blockProcessor:        blockProcessor,
 		blockBuilder:          blockBuilder,
 		consensusStateManager: consensusStateManager,
@@ -500,6 +513,8 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		headersSelectedChainStore:           headersSelectedChainStore,
 		daaBlocksStore:                      daaBlocksStore,
 		blocksWithTrustedDataDAAWindowStore: daaWindowStore,
+
+		consensusEventsChan: consensusEventsChan,
 	}
 
 	if isOldReachabilityInitialized {
@@ -562,7 +577,7 @@ func (f *factory) NewTestConsensus(config *Config, testName string) (
 	}
 
 	testConsensusDBPrefix := &prefix.Prefix{}
-	consensusAsInterface, shouldMigrate, err := f.NewConsensus(config, db, testConsensusDBPrefix)
+	consensusAsInterface, shouldMigrate, err := f.NewConsensus(config, db, testConsensusDBPrefix, nil)
 	if err != nil {
 		return nil, nil, err
 	}

domain/consensus/factory_test.go

@@ -1,10 +1,11 @@
 package consensus
 
 import (
-	"github.com/kaspanet/kaspad/domain/prefixmanager/prefix"
 	"io/ioutil"
 	"testing"
 
+	"github.com/kaspanet/kaspad/domain/prefixmanager/prefix"
+
 	"github.com/kaspanet/kaspad/domain/dagconfig"
 	"github.com/kaspanet/kaspad/infrastructure/db/database/ldb"
 )
@@ -24,7 +25,7 @@ func TestNewConsensus(t *testing.T) {
 		t.Fatalf("error in NewLevelDB: %s", err)
 	}
 
-	_, shouldMigrate, err := f.NewConsensus(config, db, &prefix.Prefix{})
+	_, shouldMigrate, err := f.NewConsensus(config, db, &prefix.Prefix{}, nil)
 	if err != nil {
 		t.Fatalf("error in NewConsensus: %+v", err)
 	}

domain/consensus/finality_test.go

@@ -3,8 +3,6 @@ package consensus_test
 import (
 	"fmt"
 	"github.com/kaspanet/kaspad/domain/consensus"
-	"testing"
-
 	"github.com/kaspanet/kaspad/domain/consensus/model"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/model/testapi"
@@ -12,6 +10,9 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
 	"github.com/pkg/errors"
+	"math"
+	"math/rand"
+	"testing"
 )
 
 func TestFinality(t *testing.T) {
@@ -32,7 +33,7 @@ func TestFinality(t *testing.T) {
 				return nil, err
 			}
 
-			_, err = consensus.ValidateAndInsertBlock(block, true)
+			err = consensus.ValidateAndInsertBlock(block, true)
 			if err != nil {
 				return nil, err
 			}
@@ -179,15 +180,20 @@ func TestFinality(t *testing.T) {
 
 func TestBoundedMergeDepth(t *testing.T) {
 	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
+		rd := rand.New(rand.NewSource(0))
 		// Set finalityInterval to 50 blocks, so that test runs quickly
 		consensusConfig.K = 5
-		consensusConfig.FinalityDuration = 7 * consensusConfig.TargetTimePerBlock
-		finalityInterval := int(consensusConfig.FinalityDepth())
+		consensusConfig.MergeDepth = 7
+		consensusConfig.FinalityDuration = 20 * consensusConfig.TargetTimePerBlock
 
-		if int(consensusConfig.K) >= finalityInterval {
+		if uint64(consensusConfig.K) >= consensusConfig.FinalityDepth() {
 			t.Fatal("K must be smaller than finality duration for this test to run")
 		}
 
+		if uint64(consensusConfig.K) >= consensusConfig.MergeDepth {
+			t.Fatal("K must be smaller than merge depth for this test to run")
+		}
+
 		checkViolatingMergeDepth := func(consensus testapi.TestConsensus, parents []*externalapi.DomainHash) (*externalapi.DomainBlock, bool) {
 			block, _, err := consensus.BuildBlockWithParents(parents, nil, nil)
 			if err != nil {
@@ -195,7 +201,7 @@ func TestBoundedMergeDepth(t *testing.T) {
 				return nil, false // fo some reason go doesn't recognize that t.Fatalf never returns
 			}
 
-			_, err = consensus.ValidateAndInsertBlock(block, true)
+			err = consensus.ValidateAndInsertBlock(block, true)
 			if err == nil {
 				return block, false
 			} else if errors.Is(err, ruleerrors.ErrViolatingBoundedMergeDepth) {
@@ -207,7 +213,7 @@ func TestBoundedMergeDepth(t *testing.T) {
 		}
 
 		processBlock := func(consensus testapi.TestConsensus, block *externalapi.DomainBlock, name string) {
-			_, err := consensus.ValidateAndInsertBlock(block, true)
+			err := consensus.ValidateAndInsertBlock(block, true)
 			if err != nil {
 				t.Fatalf("TestBoundedMergeDepth: %s got unexpected error from ProcessBlock: %+v", name, err)
 
@@ -217,9 +223,9 @@ func TestBoundedMergeDepth(t *testing.T) {
 		buildAndInsertBlock := func(consensus testapi.TestConsensus, parentHashes []*externalapi.DomainHash) *externalapi.DomainBlock {
 			block, _, err := consensus.BuildBlockWithParents(parentHashes, nil, nil)
 			if err != nil {
-				t.Fatalf("TestBoundedMergeDepth: Failed building block: %v", err)
+				t.Fatalf("TestBoundedMergeDepth: Failed building block: %+v", err)
 			}
-			_, err = consensus.ValidateAndInsertBlock(block, true)
+			err = consensus.ValidateAndInsertBlock(block, true)
 			if err != nil {
 				t.Fatalf("TestBoundedMergeDepth: Failed Inserting block to consensus: %v", err)
 			}
@@ -236,194 +242,379 @@ func TestBoundedMergeDepth(t *testing.T) {
 			return blockInfo.BlockStatus
 		}
 
-		factory := consensus.NewFactory()
-		consensusBuild, teardownFunc1, err := factory.NewTestConsensus(consensusConfig, "TestBoundedMergeTestBuild")
-		if err != nil {
-			t.Fatalf("TestBoundedMergeDepth: Error setting up consensus: %+v", err)
+		syncConsensuses := func(tcSyncer, tcSyncee testapi.TestConsensus) {
+			syncerVirtualSelectedParent, err := tcSyncer.GetVirtualSelectedParent()
+			if err != nil {
+				t.Fatalf("GetVirtualSelectedParent: %+v", err)
+			}
+
+			missingHeaderHashes, _, err := tcSyncer.GetHashesBetween(consensusConfig.GenesisHash, syncerVirtualSelectedParent, math.MaxUint64)
+			if err != nil {
+				t.Fatalf("GetHashesBetween: %+v", err)
+			}
+
+			for i, blocksHash := range missingHeaderHashes {
+				blockInfo, err := tcSyncee.GetBlockInfo(blocksHash)
+				if err != nil {
+					t.Fatalf("GetBlockInfo: %+v", err)
+				}
+
+				if blockInfo.Exists {
+					continue
+				}
+
+				block, err := tcSyncer.GetBlock(blocksHash)
+				if err != nil {
+					t.Fatalf("GetBlockHeader: %+v", err)
+				}
+
+				err = tcSyncee.ValidateAndInsertBlock(block, true)
+				if err != nil {
+					t.Fatalf("ValidateAndInsertBlock %d: %+v", i, err)
+				}
+			}
+
+			synceeVirtualSelectedParent, err := tcSyncee.GetVirtualSelectedParent()
+			if err != nil {
+				t.Fatalf("Tips: %+v", err)
+			}
+
+			if !syncerVirtualSelectedParent.Equal(synceeVirtualSelectedParent) {
+				t.Fatalf("Syncee's selected tip is %s while syncer's is %s", synceeVirtualSelectedParent, syncerVirtualSelectedParent)
+			}
 		}
 
+		factory := consensus.NewFactory()
 		consensusReal, teardownFunc2, err := factory.NewTestConsensus(consensusConfig, "TestBoundedMergeTestReal")
 		if err != nil {
 			t.Fatalf("TestBoundedMergeDepth: Error setting up consensus: %+v", err)
 		}
 		defer teardownFunc2(false)
 
-		// Create a block on top on genesis
-		block1 := buildAndInsertBlock(consensusBuild, []*externalapi.DomainHash{consensusConfig.GenesisHash})
+		test := func(depth uint64, root *externalapi.DomainHash, checkVirtual, isRealDepth bool) {
+			consensusBuild, teardownFunc1, err := factory.NewTestConsensus(consensusConfig, "TestBoundedMergeTestBuild")
+			if err != nil {
+				t.Fatalf("TestBoundedMergeDepth: Error setting up consensus: %+v", err)
+			}
+			defer teardownFunc1(false)
+			consensusBuild.BlockBuilder().SetNonceCounter(rd.Uint64())
 
-		// Create a chain
-		selectedChain := make([]*externalapi.DomainBlock, 0, finalityInterval+1)
-		parent := consensushashing.BlockHash(block1)
-		// Make sure this is always bigger than `blocksChain2` so it will stay the selected chain
-		for i := 0; i < finalityInterval+2; i++ {
-			block := buildAndInsertBlock(consensusBuild, []*externalapi.DomainHash{parent})
-			selectedChain = append(selectedChain, block)
-			parent = consensushashing.BlockHash(block)
+			syncConsensuses(consensusReal, consensusBuild)
+			// Create a block on top on genesis
+			block1 := buildAndInsertBlock(consensusBuild, []*externalapi.DomainHash{root})
+
+			// Create a chain
+			selectedChain := make([]*externalapi.DomainBlock, 0, depth+1)
+			parent := consensushashing.BlockHash(block1)
+			// Make sure this is always bigger than `blocksChain2` so it will stay the selected chain
+			for i := uint64(0); i < depth+2; i++ {
+				block := buildAndInsertBlock(consensusBuild, []*externalapi.DomainHash{parent})
+				selectedChain = append(selectedChain, block)
+				parent = consensushashing.BlockHash(block)
+			}
+
+			// Create another chain
+			blocksChain2 := make([]*externalapi.DomainBlock, 0, depth+1)
+			parent = consensushashing.BlockHash(block1)
+			for i := uint64(0); i < depth+1; i++ {
+				block := buildAndInsertBlock(consensusBuild, []*externalapi.DomainHash{parent})
+				blocksChain2 = append(blocksChain2, block)
+				parent = consensushashing.BlockHash(block)
+			}
+
+			// Now test against the real DAG
+			// submit block1
+			processBlock(consensusReal, block1, "block1")
+
+			// submit chain1
+			for i, block := range selectedChain {
+				processBlock(consensusReal, block, fmt.Sprintf("selectedChain block No %d", i))
+			}
+
+			// submit chain2
+			for i, block := range blocksChain2 {
+				processBlock(consensusReal, block, fmt.Sprintf("blocksChain2 block No %d", i))
+			}
+
+			// submit a block pointing at tip(chain1) and on first block in chain2 directly
+			mergeDepthViolatingBlockBottom, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[0]), consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
+			if isViolatingMergeDepth != isRealDepth {
+				t.Fatalf("TestBoundedMergeDepth: Expects isViolatingMergeDepth to be %t", isRealDepth)
+			}
+
+			// submit a block pointing at tip(chain1) and tip(chain2) should also obviously violate merge depth (this points at first block in chain2 indirectly)
+			mergeDepthViolatingTop, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[len(blocksChain2)-1]), consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
+			if isViolatingMergeDepth != isRealDepth {
+				t.Fatalf("TestBoundedMergeDepth: Expects isViolatingMergeDepth to be %t", isRealDepth)
+			}
+
+			// the location of the parents in the slices need to be both `-X` so the `selectedChain` one will have higher blueScore (it's a chain longer by 1)
+			kosherizingBlock, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[len(blocksChain2)-3]), consensushashing.BlockHash(selectedChain[len(selectedChain)-3])})
+			kosherizingBlockHash := consensushashing.BlockHash(kosherizingBlock)
+			if isViolatingMergeDepth {
+				t.Fatalf("TestBoundedMergeDepth: Expected blueKosherizingBlock to not violate merge depth")
+			}
+
+			if checkVirtual {
+				stagingArea := model.NewStagingArea()
+				virtualGhotDagData, err := consensusReal.GHOSTDAGDataStore().Get(consensusReal.DatabaseContext(),
+					stagingArea, model.VirtualBlockHash, false)
+				if err != nil {
+					t.Fatalf("TestBoundedMergeDepth: Failed getting the ghostdag data of the virtual: %v", err)
+				}
+				// Make sure it's actually blue
+				found := false
+				for _, blue := range virtualGhotDagData.MergeSetBlues() {
+					if blue.Equal(kosherizingBlockHash) {
+						found = true
+						break
+					}
+				}
+				if !found {
+					t.Fatalf("TestBoundedMergeDepth: Expected kosherizingBlock to be blue by the virtual")
+				}
+			}
+
+			pointAtBlueKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{kosherizingBlockHash, consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
+			if isViolatingMergeDepth {
+				t.Fatalf("TestBoundedMergeDepth: Expected selectedTip to not violate merge depth")
+			}
+
+			if checkVirtual {
+				virtualSelectedParent, err := consensusReal.GetVirtualSelectedParent()
+				if err != nil {
+					t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
+				}
+
+				if !virtualSelectedParent.Equal(consensushashing.BlockHash(pointAtBlueKosherizing)) {
+					t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensushashing.BlockHash(pointAtBlueKosherizing), virtualSelectedParent)
+				}
+			}
+
+			// Now let's make the kosherizing block red and try to merge again
+			tip := consensushashing.BlockHash(selectedChain[len(selectedChain)-1])
+			// we use k-1 because `kosherizingBlock` points at tip-2, so 2+k-1 = k+1 anticone.
+			for i := 0; i < int(consensusConfig.K)-1; i++ {
+				block := buildAndInsertBlock(consensusReal, []*externalapi.DomainHash{tip})
+				tip = consensushashing.BlockHash(block)
+			}
+
+			if checkVirtual {
+				virtualSelectedParent, err := consensusReal.GetVirtualSelectedParent()
+				if err != nil {
+					t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
+				}
+
+				if !virtualSelectedParent.Equal(tip) {
+					t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", tip, virtualSelectedParent)
+				}
+
+				virtualGhotDagData, err := consensusReal.GHOSTDAGDataStore().Get(
+					consensusReal.DatabaseContext(), model.NewStagingArea(), model.VirtualBlockHash, false)
+				if err != nil {
+					t.Fatalf("TestBoundedMergeDepth: Failed getting the ghostdag data of the virtual: %v", err)
+				}
+				// Make sure it's actually blue
+				found := false
+				for _, blue := range virtualGhotDagData.MergeSetBlues() {
+					if blue.Equal(kosherizingBlockHash) {
+						found = true
+						break
+					}
+				}
+				if found {
+					t.Fatalf("expected kosherizingBlock to be red by the virtual")
+				}
+			}
+
+			pointAtRedKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{kosherizingBlockHash, tip})
+			if isViolatingMergeDepth != isRealDepth {
+				t.Fatalf("TestBoundedMergeDepth: Expects isViolatingMergeDepth to be %t", isRealDepth)
+			}
+
+			// Now `pointAtBlueKosherizing` itself is actually still blue, so we can still point at that even though we can't point at kosherizing directly anymore
+			transitiveBlueKosherizing, isViolatingMergeDepth :=
+				checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(pointAtBlueKosherizing), tip})
+			if isViolatingMergeDepth {
+				t.Fatalf("TestBoundedMergeDepth: Expected transitiveBlueKosherizing to not violate merge depth")
+			}
+
+			if checkVirtual {
+				virtualSelectedParent, err := consensusReal.GetVirtualSelectedParent()
+				if err != nil {
+					t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
+				}
+
+				if !virtualSelectedParent.Equal(consensushashing.BlockHash(transitiveBlueKosherizing)) {
+					t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensushashing.BlockHash(transitiveBlueKosherizing), virtualSelectedParent)
+				}
+
+				// Lets validate the status of all the interesting blocks
+				if getStatus(consensusReal, pointAtBlueKosherizing) != externalapi.StatusUTXOValid {
+					t.Fatalf("TestBoundedMergeDepth: pointAtBlueKosherizing expected status '%s' but got '%s'", externalapi.StatusUTXOValid, getStatus(consensusReal, pointAtBlueKosherizing))
+				}
+				if getStatus(consensusReal, pointAtRedKosherizing) != externalapi.StatusInvalid {
+					t.Fatalf("TestBoundedMergeDepth: pointAtRedKosherizing expected status '%s' but got '%s'", externalapi.StatusInvalid, getStatus(consensusReal, pointAtRedKosherizing))
+				}
+				if getStatus(consensusReal, transitiveBlueKosherizing) != externalapi.StatusUTXOValid {
+					t.Fatalf("TestBoundedMergeDepth: transitiveBlueKosherizing expected status '%s' but got '%s'", externalapi.StatusUTXOValid, getStatus(consensusReal, transitiveBlueKosherizing))
+				}
+				if getStatus(consensusReal, mergeDepthViolatingBlockBottom) != externalapi.StatusInvalid {
+					t.Fatalf("TestBoundedMergeDepth: mergeDepthViolatingBlockBottom expected status '%s' but got '%s'", externalapi.StatusInvalid, getStatus(consensusReal, mergeDepthViolatingBlockBottom))
+				}
+				if getStatus(consensusReal, mergeDepthViolatingTop) != externalapi.StatusInvalid {
+					t.Fatalf("TestBoundedMergeDepth: mergeDepthViolatingTop expected status '%s' but got '%s'", externalapi.StatusInvalid, getStatus(consensusReal, mergeDepthViolatingTop))
+				}
+				if getStatus(consensusReal, kosherizingBlock) != externalapi.StatusUTXOPendingVerification {
+					t.Fatalf("kosherizingBlock expected status '%s' but got '%s'", externalapi.StatusUTXOPendingVerification, getStatus(consensusReal, kosherizingBlock))
+				}
+
+				for i, b := range blocksChain2 {
+					if getStatus(consensusReal, b) != externalapi.StatusUTXOPendingVerification {
+						t.Fatalf("blocksChain2[%d] expected status '%s' but got '%s'", i, externalapi.StatusUTXOPendingVerification, getStatus(consensusReal, b))
+					}
+				}
+				for i, b := range selectedChain {
+					if getStatus(consensusReal, b) != externalapi.StatusUTXOValid {
+						t.Fatalf("selectedChain[%d] expected status '%s' but got '%s'", i, externalapi.StatusUTXOValid, getStatus(consensusReal, b))
+					}
+				}
+			}
 		}
 
-		// Create another chain
-		blocksChain2 := make([]*externalapi.DomainBlock, 0, finalityInterval+1)
-		parent = consensushashing.BlockHash(block1)
-		for i := 0; i < finalityInterval+1; i++ {
-			block := buildAndInsertBlock(consensusBuild, []*externalapi.DomainHash{parent})
-			blocksChain2 = append(blocksChain2, block)
-			parent = consensushashing.BlockHash(block)
+		test(consensusConfig.MergeDepth, consensusConfig.GenesisHash, true, true)
+	})
+}
+
+func TestFinalityResolveVirtual(t *testing.T) {
+	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
+		// Set finalityInterval to 20 blocks, so that test runs quickly
+		consensusConfig.FinalityDuration = 20 * consensusConfig.TargetTimePerBlock
+
+		factory := consensus.NewFactory()
+		tc, teardown, err := factory.NewTestConsensus(consensusConfig, "TestFinalityResolveVirtual")
+		if err != nil {
+			panic(err)
+		}
+		defer teardown(false)
+
+		tip := consensusConfig.GenesisHash
+		for {
+			tip, _, err = tc.AddBlock([]*externalapi.DomainHash{tip}, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			virtualFinalityPoint, err := tc.FinalityManager().VirtualFinalityPoint(model.NewStagingArea())
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if !virtualFinalityPoint.Equal(consensusConfig.GenesisHash) {
+				break
+			}
 		}
 
-		// Teardown and assign nil to make sure we use the right DAG from here on.
-		teardownFunc1(false)
-		consensusBuild = nil
-
-		// Now test against the real DAG
-		// submit block1
-		processBlock(consensusReal, block1, "block1")
-
-		// submit chain1
-		for i, block := range selectedChain {
-			processBlock(consensusReal, block, fmt.Sprintf("selectedChain block No %d", i))
+		tcAttacker, teardownAttacker, err := factory.NewTestConsensus(consensusConfig, "TestFinalityResolveVirtual_attacker")
+		if err != nil {
+			panic(err)
 		}
+		defer teardownAttacker(false)
 
-		// submit chain2
-		for i, block := range blocksChain2 {
-			processBlock(consensusReal, block, fmt.Sprintf("blocksChain2 block No %d", i))
-		}
-
-		// submit a block pointing at tip(chain1) and on first block in chain2 directly
-		mergeDepthViolatingBlockBottom, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[0]), consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
-		if !isViolatingMergeDepth {
-			t.Fatalf("TestBoundedMergeDepth: Expected mergeDepthViolatingBlockBottom to violate merge depth")
-		}
-
-		// submit a block pointing at tip(chain1) and tip(chain2) should also obviously violate merge depth (this points at first block in chain2 indirectly)
-		mergeDepthViolatingTop, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[len(blocksChain2)-1]), consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
-		if !isViolatingMergeDepth {
-			t.Fatalf("TestBoundedMergeDepth: Expected mergeDepthViolatingTop to violate merge depth")
-		}
-
-		// the location of the parents in the slices need to be both `-X` so the `selectedChain` one will have higher blueScore (it's a chain longer by 1)
-		kosherizingBlock, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[len(blocksChain2)-3]), consensushashing.BlockHash(selectedChain[len(selectedChain)-3])})
-		kosherizingBlockHash := consensushashing.BlockHash(kosherizingBlock)
-		if isViolatingMergeDepth {
-			t.Fatalf("TestBoundedMergeDepth: Expected blueKosherizingBlock to not violate merge depth")
+		virtualSelectedParent, err := tc.GetVirtualSelectedParent()
+		if err != nil {
+			panic(err)
 		}
 
 		stagingArea := model.NewStagingArea()
-		virtualGhotDagData, err := consensusReal.GHOSTDAGDataStore().Get(consensusReal.DatabaseContext(),
-			stagingArea, model.VirtualBlockHash, false)
+		virtualSelectedParentGHOSTDAGData, err := tc.GHOSTDAGDataStore().Get(tc.DatabaseContext(), stagingArea, virtualSelectedParent, false)
 		if err != nil {
-			t.Fatalf("TestBoundedMergeDepth: Failed getting the ghostdag data of the virtual: %v", err)
+			panic(err)
 		}
-		// Make sure it's actually blue
-		found := false
-		for _, blue := range virtualGhotDagData.MergeSetBlues() {
-			if blue.Equal(kosherizingBlockHash) {
-				found = true
+
+		t.Logf("Selected tip blue score %d", virtualSelectedParentGHOSTDAGData.BlueScore())
+
+		sideChain := make([]*externalapi.DomainBlock, 0)
+
+		for i := uint64(0); ; i++ {
+			tips, err := tcAttacker.Tips()
+			if err != nil {
+				panic(err)
+			}
+
+			block, _, err := tcAttacker.BuildBlockWithParents(tips, nil, nil)
+			if err != nil {
+				panic(err)
+			}
+
+			// We change the nonce of the first block so its hash won't be similar to any of the
+			// honest DAG blocks. As a result the rest of the side chain should have unique hashes
+			// as well.
+			if i == 0 {
+				mutableHeader := block.Header.ToMutable()
+				mutableHeader.SetNonce(uint64(rand.NewSource(84147).Int63()))
+				block.Header = mutableHeader.ToImmutable()
+			}
+
+			err = tcAttacker.ValidateAndInsertBlock(block, true)
+			if err != nil {
+				panic(err)
+			}
+
+			sideChain = append(sideChain, block)
+
+			blockHash := consensushashing.BlockHash(block)
+			ghostdagData, err := tcAttacker.GHOSTDAGDataStore().Get(tcAttacker.DatabaseContext(), stagingArea, blockHash, false)
+			if err != nil {
+				panic(err)
+			}
+
+			if virtualSelectedParentGHOSTDAGData.BlueWork().Cmp(ghostdagData.BlueWork()) == -1 {
 				break
 			}
 		}
-		if !found {
-			t.Fatalf("TestBoundedMergeDepth: Expected kosherizingBlock to be blue by the virtual")
-		}
 
-		pointAtBlueKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{kosherizingBlockHash, consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
-		if isViolatingMergeDepth {
-
-			t.Fatalf("TestBoundedMergeDepth: Expected selectedTip to not violate merge depth")
-		}
-
-		virtualSelectedParent, err := consensusReal.GetVirtualSelectedParent()
+		sideChainTipHash := consensushashing.BlockHash(sideChain[len(sideChain)-1])
+		sideChainTipGHOSTDAGData, err := tcAttacker.GHOSTDAGDataStore().Get(tcAttacker.DatabaseContext(), stagingArea, sideChainTipHash, false)
 		if err != nil {
-			t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
+			panic(err)
 		}
 
-		if !virtualSelectedParent.Equal(consensushashing.BlockHash(pointAtBlueKosherizing)) {
-			t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensushashing.BlockHash(pointAtBlueKosherizing), virtualSelectedParent)
+		t.Logf("Side chain tip (%s) blue score %d", sideChainTipHash, sideChainTipGHOSTDAGData.BlueScore())
+
+		for _, block := range sideChain {
+			err := tc.ValidateAndInsertBlock(block, false)
+			if err != nil {
+				panic(err)
+			}
 		}
 
-		// Now let's make the kosherizing block red and try to merge again
-		tip := consensushashing.BlockHash(selectedChain[len(selectedChain)-1])
-		// we use k-1 because `kosherizingBlock` points at tip-2, so 2+k-1 = k+1 anticone.
-		for i := 0; i < int(consensusConfig.K)-1; i++ {
-			block := buildAndInsertBlock(consensusReal, []*externalapi.DomainHash{tip})
-			tip = consensushashing.BlockHash(block)
-		}
+		for i := 0; ; i++ {
+			isCompletelyResolved, err := tc.ResolveVirtual()
+			if err != nil {
+				panic(err)
+			}
 
-		virtualSelectedParent, err = consensusReal.GetVirtualSelectedParent()
-		if err != nil {
-			t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
-		}
-
-		if !virtualSelectedParent.Equal(tip) {
-			t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", tip, virtualSelectedParent)
-		}
-
-		virtualGhotDagData, err = consensusReal.GHOSTDAGDataStore().Get(
-			consensusReal.DatabaseContext(), stagingArea, model.VirtualBlockHash, false)
-		if err != nil {
-			t.Fatalf("TestBoundedMergeDepth: Failed getting the ghostdag data of the virtual: %v", err)
-		}
-		// Make sure it's actually blue
-		found = false
-		for _, blue := range virtualGhotDagData.MergeSetBlues() {
-			if blue.Equal(kosherizingBlockHash) {
-				found = true
+			if isCompletelyResolved {
+				t.Log("Resolved virtual")
 				break
 			}
 		}
-		if found {
-			t.Fatalf("expected kosherizingBlock to be red by the virtual")
-		}
 
-		pointAtRedKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{kosherizingBlockHash, tip})
-		if !isViolatingMergeDepth {
-			t.Fatalf("TestBoundedMergeDepth: Expected selectedTipRedKosherize to violate merge depth")
-		}
-
-		// Now `pointAtBlueKosherizing` itself is actually still blue, so we can still point at that even though we can't point at kosherizing directly anymore
-		transitiveBlueKosherizing, isViolatingMergeDepth :=
-			checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(pointAtBlueKosherizing), tip})
-		if isViolatingMergeDepth {
-			t.Fatalf("TestBoundedMergeDepth: Expected transitiveBlueKosherizing to not violate merge depth")
-		}
-
-		virtualSelectedParent, err = consensusReal.GetVirtualSelectedParent()
+		sideChainTipGHOSTDAGData, err = tc.GHOSTDAGDataStore().Get(tc.DatabaseContext(), stagingArea, sideChainTipHash, false)
 		if err != nil {
-			t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
+			panic(err)
 		}
 
-		if !virtualSelectedParent.Equal(consensushashing.BlockHash(transitiveBlueKosherizing)) {
-			t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensushashing.BlockHash(transitiveBlueKosherizing), virtualSelectedParent)
+		t.Logf("Side chain tip (%s) blue score %d", sideChainTipHash, sideChainTipGHOSTDAGData.BlueScore())
+
+		newVirtualSelectedParent, err := tc.GetVirtualSelectedParent()
+		if err != nil {
+			panic(err)
 		}
 
-		// Lets validate the status of all the interesting blocks
-		if getStatus(consensusReal, pointAtBlueKosherizing) != externalapi.StatusUTXOValid {
-			t.Fatalf("TestBoundedMergeDepth: pointAtBlueKosherizing expected status '%s' but got '%s'", externalapi.StatusUTXOValid, getStatus(consensusReal, pointAtBlueKosherizing))
-		}
-		if getStatus(consensusReal, pointAtRedKosherizing) != externalapi.StatusInvalid {
-			t.Fatalf("TestBoundedMergeDepth: pointAtRedKosherizing expected status '%s' but got '%s'", externalapi.StatusInvalid, getStatus(consensusReal, pointAtRedKosherizing))
-		}
-		if getStatus(consensusReal, transitiveBlueKosherizing) != externalapi.StatusUTXOValid {
-			t.Fatalf("TestBoundedMergeDepth: transitiveBlueKosherizing expected status '%s' but got '%s'", externalapi.StatusUTXOValid, getStatus(consensusReal, transitiveBlueKosherizing))
-		}
-		if getStatus(consensusReal, mergeDepthViolatingBlockBottom) != externalapi.StatusInvalid {
-			t.Fatalf("TestBoundedMergeDepth: mergeDepthViolatingBlockBottom expected status '%s' but got '%s'", externalapi.StatusInvalid, getStatus(consensusReal, mergeDepthViolatingBlockBottom))
-		}
-		if getStatus(consensusReal, mergeDepthViolatingTop) != externalapi.StatusInvalid {
-			t.Fatalf("TestBoundedMergeDepth: mergeDepthViolatingTop expected status '%s' but got '%s'", externalapi.StatusInvalid, getStatus(consensusReal, mergeDepthViolatingTop))
-		}
-		if getStatus(consensusReal, kosherizingBlock) != externalapi.StatusUTXOPendingVerification {
-			t.Fatalf("kosherizingBlock expected status '%s' but got '%s'", externalapi.StatusUTXOPendingVerification, getStatus(consensusReal, kosherizingBlock))
-		}
-
-		for i, b := range blocksChain2 {
-			if getStatus(consensusReal, b) != externalapi.StatusUTXOPendingVerification {
-				t.Fatalf("blocksChain2[%d] expected status '%s' but got '%s'", i, externalapi.StatusUTXOPendingVerification, getStatus(consensusReal, b))
-			}
-		}
-		for i, b := range selectedChain {
-			if getStatus(consensusReal, b) != externalapi.StatusUTXOValid {
-				t.Fatalf("selectedChain[%d] expected status '%s' but got '%s'", i, externalapi.StatusUTXOValid, getStatus(consensusReal, b))
-			}
+		if !newVirtualSelectedParent.Equal(virtualSelectedParent) {
+			t.Fatalf("A finality reorg has happened")
 		}
 	})
 }

domain/consensus/model/externalapi/blocktemplate.go

@@ -5,6 +5,7 @@ type DomainBlockTemplate struct {
 	Block                *DomainBlock
 	CoinbaseData         *DomainCoinbaseData
 	CoinbaseHasRedReward bool
+	IsNearlySynced       bool
 }
 
 // Clone returns a clone of DomainBlockTemplate
@@ -13,5 +14,6 @@ func (bt *DomainBlockTemplate) Clone() *DomainBlockTemplate {
 		Block:                bt.Block.Clone(),
 		CoinbaseData:         bt.CoinbaseData.Clone(),
 		CoinbaseHasRedReward: bt.CoinbaseHasRedReward,
+		IsNearlySynced:       bt.IsNearlySynced,
 	}
 }

domain/consensus/model/externalapi/consensus.go

@@ -4,9 +4,9 @@ package externalapi
 type Consensus interface {
 	Init(skipAddingGenesis bool) error
 	BuildBlock(coinbaseData *DomainCoinbaseData, transactions []*DomainTransaction) (*DomainBlock, error)
-	BuildBlockWithTemplateMetadata(coinbaseData *DomainCoinbaseData, transactions []*DomainTransaction) (block *DomainBlock, coinbaseHasRedReward bool, err error)
-	ValidateAndInsertBlock(block *DomainBlock, shouldValidateAgainstUTXO bool) (*VirtualChangeSet, error)
-	ValidateAndInsertBlockWithTrustedData(block *BlockWithTrustedData, validateUTXO bool) (*VirtualChangeSet, error)
+	BuildBlockTemplate(coinbaseData *DomainCoinbaseData, transactions []*DomainTransaction) (*DomainBlockTemplate, error)
+	ValidateAndInsertBlock(block *DomainBlock, shouldValidateAgainstUTXO bool) error
+	ValidateAndInsertBlockWithTrustedData(block *BlockWithTrustedData, validateUTXO bool) error
 	ValidateTransactionAndPopulateWithConsensusData(transaction *DomainTransaction) error
 	ImportPruningPoints(pruningPoints []BlockHeader) error
 	BuildPruningPointProof() (*PruningPointProof, error)
@@ -19,6 +19,7 @@ type Consensus interface {
 	GetBlockInfo(blockHash *DomainHash) (*BlockInfo, error)
 	GetBlockRelations(blockHash *DomainHash) (parents []*DomainHash, children []*DomainHash, err error)
 	GetBlockAcceptanceData(blockHash *DomainHash) (AcceptanceData, error)
+	GetBlocksAcceptanceData(blockHashes []*DomainHash) ([]AcceptanceData, error)
 
 	GetHashesBetween(lowHash, highHash *DomainHash, maxBlocks uint64) (hashes []*DomainHash, actualHighHash *DomainHash, err error)
 	GetAnticone(blockHash, contextHash *DomainHash, maxBlocks uint64) (hashes []*DomainHash, err error)
@@ -47,10 +48,12 @@ type Consensus interface {
 	Anticone(blockHash *DomainHash) ([]*DomainHash, error)
 	EstimateNetworkHashesPerSecond(startHash *DomainHash, windowSize int) (uint64, error)
 	PopulateMass(transaction *DomainTransaction)
-	ResolveVirtual() (*VirtualChangeSet, bool, error)
+	ResolveVirtual() (bool, error)
 	BlockDAAWindowHashes(blockHash *DomainHash) ([]*DomainHash, error)
 	TrustedDataDataDAAHeader(trustedBlockHash, daaBlockHash *DomainHash, daaBlockWindowIndex uint64) (*TrustedDataDataDAAHeader, error)
 	TrustedBlockAssociatedGHOSTDAGDataBlockHashes(blockHash *DomainHash) ([]*DomainHash, error)
 	TrustedGHOSTDAGData(blockHash *DomainHash) (*BlockGHOSTDAGData, error)
 	IsChainBlock(blockHash *DomainHash) (bool, error)
+	VirtualMergeDepthRoot() (*DomainHash, error)
+	IsNearlySynced() (bool, error)
 }

domain/consensus/model/externalapi/consensus_events.go

@@ -0,0 +1,30 @@
+package externalapi
+
+// ConsensusEvent is an interface type that is implemented by all events raised by consensus
+type ConsensusEvent interface {
+	isConsensusEvent()
+}
+
+// BlockAdded is an event raised by consensus when a block was added to the dag
+type BlockAdded struct {
+	Block *DomainBlock
+}
+
+func (*BlockAdded) isConsensusEvent() {}
+
+// VirtualChangeSet is an event raised by consensus when virtual changes
+type VirtualChangeSet struct {
+	VirtualSelectedParentChainChanges *SelectedChainPath
+	VirtualUTXODiff                   UTXODiff
+	VirtualParents                    []*DomainHash
+	VirtualSelectedParentBlueScore    uint64
+	VirtualDAAScore                   uint64
+}
+
+func (*VirtualChangeSet) isConsensusEvent() {}
+
+// SelectedChainPath is a path the of the selected chains between two blocks.
+type SelectedChainPath struct {
+	Added   []*DomainHash
+	Removed []*DomainHash
+}

domain/consensus/model/externalapi/utxoentry.go

@@ -1,13 +1,13 @@
 package externalapi
 
 // UTXOEntry houses details about an individual transaction output in a utxo
-// set such as whether or not it was contained in a coinbase tx, the blue
+// set such as whether or not it was contained in a coinbase tx, the daa
 // score of the block that accepts the tx, its public key script, and how
 // much it pays.
 type UTXOEntry interface {
-	Amount() uint64
+	Amount() uint64                    // Utxo amount in Sompis
 	ScriptPublicKey() *ScriptPublicKey // The public key script for the output.
-	BlockDAAScore() uint64             // Blue score of the block accepting the tx.
+	BlockDAAScore() uint64             // Daa score of the block accepting the tx.
 	IsCoinbase() bool
 	Equal(other UTXOEntry) bool
 }

domain/consensus/model/externalapi/virtualchangeset.go

@@ -1,14 +0,0 @@
-package externalapi
-
-// VirtualChangeSet is auxiliary data returned from ValidateAndInsertBlock and ResolveVirtual
-type VirtualChangeSet struct {
-	VirtualSelectedParentChainChanges *SelectedChainPath
-	VirtualUTXODiff                   UTXODiff
-	VirtualParents                    []*DomainHash
-}
-
-// SelectedChainPath is a path the of the selected chains between two blocks.
-type SelectedChainPath struct {
-	Added   []*DomainHash
-	Removed []*DomainHash
-}

domain/consensus/model/interface_datastructures_mergedepthrootstore.go

@@ -0,0 +1,13 @@
+package model
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MergeDepthRootStore represents a store for merge depth roots
+type MergeDepthRootStore interface {
+	Store
+	IsStaged(stagingArea *StagingArea) bool
+	StageMergeDepthRoot(stagingArea *StagingArea, blockHash *externalapi.DomainHash, root *externalapi.DomainHash)
+	MergeDepthRoot(dbContext DBReader, stagingArea *StagingArea, blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error)
+}

domain/consensus/model/interface_processes_blockprocessor.go

@@ -4,7 +4,7 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 
 // BlockProcessor is responsible for processing incoming blocks
 type BlockProcessor interface {
-	ValidateAndInsertBlock(block *externalapi.DomainBlock, shouldValidateAgainstUTXO bool) (*externalapi.VirtualChangeSet, error)
+	ValidateAndInsertBlock(block *externalapi.DomainBlock, shouldValidateAgainstUTXO bool) (*externalapi.VirtualChangeSet, externalapi.BlockStatus, error)
 	ValidateAndInsertImportedPruningPoint(newPruningPoint *externalapi.DomainHash) error
-	ValidateAndInsertBlockWithTrustedData(block *externalapi.BlockWithTrustedData, validateUTXO bool) (*externalapi.VirtualChangeSet, error)
+	ValidateAndInsertBlockWithTrustedData(block *externalapi.BlockWithTrustedData, validateUTXO bool) (*externalapi.VirtualChangeSet, externalapi.BlockStatus, error)
 }

domain/consensus/model/interface_processes_mergedepthmanager.go

@@ -5,5 +5,7 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 // MergeDepthManager is used to validate mergeDepth for blocks
 type MergeDepthManager interface {
 	CheckBoundedMergeDepth(stagingArea *StagingArea, blockHash *externalapi.DomainHash, isBlockWithTrustedData bool) error
-	NonBoundedMergeDepthViolatingBlues(stagingArea *StagingArea, blockHash *externalapi.DomainHash, isBlockWithTrustedData bool) ([]*externalapi.DomainHash, error)
+	NonBoundedMergeDepthViolatingBlues(stagingArea *StagingArea, blockHash, mergeDepthRoot *externalapi.DomainHash) ([]*externalapi.DomainHash, error)
+	VirtualMergeDepthRoot(stagingArea *StagingArea) (*externalapi.DomainHash, error)
+	MergeDepthRoot(stagingArea *StagingArea, blockHash *externalapi.DomainHash, isBlockWithTrustedData bool) (*externalapi.DomainHash, error)
 }

domain/consensus/model/interface_processes_transactionvalidator.go

@@ -7,7 +7,7 @@ import (
 // TransactionValidator exposes a set of validation classes, after which
 // it's possible to determine whether a transaction is valid
 type TransactionValidator interface {
-	ValidateTransactionInIsolation(transaction *externalapi.DomainTransaction) error
+	ValidateTransactionInIsolation(transaction *externalapi.DomainTransaction, povDAAScore uint64) error
 	ValidateTransactionInContextIgnoringUTXO(stagingArea *StagingArea, tx *externalapi.DomainTransaction,
 		povBlockHash *externalapi.DomainHash, povBlockPastMedianTime int64) error
 	ValidateTransactionInContextAndPopulateFee(stagingArea *StagingArea,

domain/consensus/model/staging_area.go

@@ -1,6 +1,8 @@
 package model
 
-import "github.com/pkg/errors"
+import (
+	"github.com/pkg/errors"
+)
 
 // StagingShard is an interface that enables every store to have it's own Commit logic
 // See StagingArea for more details
@@ -19,14 +21,14 @@ type StagingShardID uint64
 // When the StagingArea is being Committed, it goes over all it's shards, and commits those one-by-one.
 // Since Commit happens in a DatabaseTransaction, a StagingArea is atomic.
 type StagingArea struct {
-	shards      []StagingShard
+	shards      map[StagingShardID]StagingShard
 	isCommitted bool
 }
 
 // NewStagingArea creates a new, empty staging area.
 func NewStagingArea() *StagingArea {
 	return &StagingArea{
-		shards:      []StagingShard{},
+		shards:      make(map[StagingShardID]StagingShard),
 		isCommitted: false,
 	}
 }
@@ -34,14 +36,12 @@ func NewStagingArea() *StagingArea {
 // GetOrCreateShard attempts to retrieve a shard with the given name.
 // If it does not exist - a new shard is created using `createFunc`.
 func (sa *StagingArea) GetOrCreateShard(shardID StagingShardID, createFunc func() StagingShard) StagingShard {
-	for uint64(len(sa.shards)) <= uint64(shardID) {
-		sa.shards = append(sa.shards, nil)
+	shard, ok := sa.shards[shardID]
+	if !ok {
+		shard = createFunc()
+		sa.shards[shardID] = shard
 	}
-	if sa.shards[shardID] == nil {
-		sa.shards[shardID] = createFunc()
-	}
-
-	return sa.shards[shardID]
+	return shard
 }
 
 // Commit goes over all the Shards in the StagingArea and commits them, inside the provided database transaction.
@@ -52,9 +52,6 @@ func (sa *StagingArea) Commit(dbTx DBTransaction) error {
 	}
 
 	for _, shard := range sa.shards {
-		if shard == nil { // since sa.shards is an array and not a map, some shard slots might be empty.
-			continue
-		}
 		err := shard.Commit(dbTx)
 		if err != nil {
 			return err

domain/consensus/model/testapi/test_block_builder.go

@@ -18,4 +18,6 @@ type TestBlockBuilder interface {
 
 	BuildUTXOInvalidBlock(parentHashes []*externalapi.DomainHash) (*externalapi.DomainBlock,
 		error)
+
+	SetNonceCounter(nonceCounter uint64)
 }

domain/consensus/model/testapi/test_consensus.go

@@ -47,6 +47,9 @@ type TestConsensus interface {
 
 	AddUTXOInvalidBlock(parentHashes []*externalapi.DomainHash) (*externalapi.DomainHash,
 		*externalapi.VirtualChangeSet, error)
+	UpdatePruningPointByVirtual() error
+
+	ResolveVirtualWithMaxParam(maxBlocksToResolve uint64) (bool, error)
 
 	MineJSON(r io.Reader, blockType MineJSONBlockType) (tips []*externalapi.DomainHash, err error)
 	ToJSON(w io.Writer) error

domain/consensus/processes/blockbuilder/block_builder.go

@@ -225,7 +225,7 @@ func (bb *blockBuilder) buildHeader(stagingArea *model.StagingArea, transactions
 	}
 
 	return blockheader.NewImmutableBlockHeader(
-		constants.MaxBlockVersion,
+		constants.BlockVersion,
 		parents,
 		hashMerkleRoot,
 		acceptedIDMerkleRoot,

domain/consensus/processes/blockbuilder/test_block_builder.go

@@ -96,7 +96,7 @@ func (bb *testBlockBuilder) buildUTXOInvalidHeader(stagingArea *model.StagingAre
 
 	bb.nonceCounter++
 	return blockheader.NewImmutableBlockHeader(
-		constants.MaxBlockVersion,
+		constants.BlockVersion,
 		parents,
 		hashMerkleRoot,
 		&externalapi.DomainHash{},
@@ -283,3 +283,7 @@ func (bb *testBlockBuilder) BuildUTXOInvalidBlock(parentHashes []*externalapi.Do
 		Transactions: transactions,
 	}, nil
 }
+
+func (bb *testBlockBuilder) SetNonceCounter(nonceCounter uint64) {
+	bb.nonceCounter = nonceCounter
+}

domain/consensus/processes/blockprocessor/blockprocessor.go

@@ -28,6 +28,7 @@ type blockProcessor struct {
 	coinbaseManager       model.CoinbaseManager
 	headerTipsManager     model.HeadersSelectedTipManager
 	syncManager           model.SyncManager
+	finalityManager       model.FinalityManager
 
 	acceptanceDataStore                 model.AcceptanceDataStore
 	blockStore                          model.BlockStore
@@ -143,7 +144,8 @@ func New(
 
 // ValidateAndInsertBlock validates the given block and, if valid, applies it
 // to the current state
-func (bp *blockProcessor) ValidateAndInsertBlock(block *externalapi.DomainBlock, shouldValidateAgainstUTXO bool) (*externalapi.VirtualChangeSet, error) {
+func (bp *blockProcessor) ValidateAndInsertBlock(block *externalapi.DomainBlock,
+	shouldValidateAgainstUTXO bool) (*externalapi.VirtualChangeSet, externalapi.BlockStatus, error) {
 	onEnd := logger.LogAndMeasureExecutionTime(log, "ValidateAndInsertBlock")
 	defer onEnd()
 
@@ -159,7 +161,8 @@ func (bp *blockProcessor) ValidateAndInsertImportedPruningPoint(newPruningPoint
 	return bp.validateAndInsertImportedPruningPoint(stagingArea, newPruningPoint)
 }
 
-func (bp *blockProcessor) ValidateAndInsertBlockWithTrustedData(block *externalapi.BlockWithTrustedData, shouldValidateAgainstUTXO bool) (*externalapi.VirtualChangeSet, error) {
+func (bp *blockProcessor) ValidateAndInsertBlockWithTrustedData(block *externalapi.BlockWithTrustedData,
+	shouldValidateAgainstUTXO bool) (*externalapi.VirtualChangeSet, externalapi.BlockStatus, error) {
 	onEnd := logger.LogAndMeasureExecutionTime(log, "ValidateAndInsertBlockWithTrustedData")
 	defer onEnd()
 

domain/consensus/processes/blockprocessor/validate_and_insert_block.go

@@ -18,18 +18,18 @@ import (
 )
 
 func (bp *blockProcessor) setBlockStatusAfterBlockValidation(
-	stagingArea *model.StagingArea, block *externalapi.DomainBlock, isPruningPoint bool) error {
+	stagingArea *model.StagingArea, block *externalapi.DomainBlock, isPruningPoint bool) (externalapi.BlockStatus, error) {
 
 	blockHash := consensushashing.BlockHash(block)
 
 	exists, err := bp.blockStatusStore.Exists(bp.databaseContext, stagingArea, blockHash)
 	if err != nil {
-		return err
+		return externalapi.StatusInvalid, err
 	}
 	if exists {
 		status, err := bp.blockStatusStore.Get(bp.databaseContext, stagingArea, blockHash)
 		if err != nil {
-			return err
+			return externalapi.StatusInvalid, err
 		}
 
 		if status == externalapi.StatusUTXOValid {
@@ -38,12 +38,12 @@ func (bp *blockProcessor) setBlockStatusAfterBlockValidation(
 			// The only exception is the pruning point because its status is manually set before inserting
 			// the block.
 			if !isPruningPoint {
-				return errors.Errorf("block %s that is not the pruning point is not expected to be valid "+
+				return externalapi.StatusInvalid, errors.Errorf("block %s that is not the pruning point is not expected to be valid "+
 					"before adding to to the consensus state manager", blockHash)
 			}
 			log.Debugf("Block %s is the pruning point and has status %s, so leaving its status untouched",
 				blockHash, status)
-			return nil
+			return status, nil
 		}
 	}
 
@@ -52,13 +52,13 @@ func (bp *blockProcessor) setBlockStatusAfterBlockValidation(
 		log.Debugf("Block %s is a header-only block so setting its status as %s",
 			blockHash, externalapi.StatusHeaderOnly)
 		bp.blockStatusStore.Stage(stagingArea, blockHash, externalapi.StatusHeaderOnly)
-	} else {
-		log.Debugf("Block %s has body so setting its status as %s",
-			blockHash, externalapi.StatusUTXOPendingVerification)
-		bp.blockStatusStore.Stage(stagingArea, blockHash, externalapi.StatusUTXOPendingVerification)
+		return externalapi.StatusHeaderOnly, nil
 	}
 
-	return nil
+	log.Debugf("Block %s has body so setting its status as %s",
+		blockHash, externalapi.StatusUTXOPendingVerification)
+	bp.blockStatusStore.Stage(stagingArea, blockHash, externalapi.StatusUTXOPendingVerification)
+	return externalapi.StatusUTXOPendingVerification, nil
 }
 
 func (bp *blockProcessor) updateVirtualAcceptanceDataAfterImportingPruningPoint(stagingArea *model.StagingArea) error {
@@ -77,29 +77,29 @@ func (bp *blockProcessor) updateVirtualAcceptanceDataAfterImportingPruningPoint(
 }
 
 func (bp *blockProcessor) validateAndInsertBlock(stagingArea *model.StagingArea, block *externalapi.DomainBlock,
-	isPruningPoint bool, shouldValidateAgainstUTXO bool, isBlockWithTrustedData bool) (*externalapi.VirtualChangeSet, error) {
+	isPruningPoint bool, shouldValidateAgainstUTXO bool, isBlockWithTrustedData bool) (*externalapi.VirtualChangeSet, externalapi.BlockStatus, error) {
 
 	blockHash := consensushashing.HeaderHash(block.Header)
 	err := bp.validateBlock(stagingArea, block, isBlockWithTrustedData)
 	if err != nil {
-		return nil, err
+		return nil, externalapi.StatusInvalid, err
 	}
 
-	err = bp.setBlockStatusAfterBlockValidation(stagingArea, block, isPruningPoint)
+	status, err := bp.setBlockStatusAfterBlockValidation(stagingArea, block, isPruningPoint)
 	if err != nil {
-		return nil, err
+		return nil, externalapi.StatusInvalid, err
 	}
 
 	var oldHeadersSelectedTip *externalapi.DomainHash
 	hasHeaderSelectedTip, err := bp.headersSelectedTipStore.Has(bp.databaseContext, stagingArea)
 	if err != nil {
-		return nil, err
+		return nil, externalapi.StatusInvalid, err
 	}
 	if hasHeaderSelectedTip {
 		var err error
 		oldHeadersSelectedTip, err = bp.headersSelectedTipStore.HeadersSelectedTip(bp.databaseContext, stagingArea)
 		if err != nil {
-			return nil, err
+			return nil, externalapi.StatusInvalid, err
 		}
 	}
 
@@ -109,12 +109,12 @@ func (bp *blockProcessor) validateAndInsertBlock(stagingArea *model.StagingArea,
 	} else {
 		pruningPoint, err := bp.pruningStore.PruningPoint(bp.databaseContext, stagingArea)
 		if err != nil {
-			return nil, err
+			return nil, externalapi.StatusInvalid, err
 		}
 
 		isInSelectedChainOfPruningPoint, err := bp.dagTopologyManager.IsInSelectedParentChainOf(stagingArea, pruningPoint, blockHash)
 		if err != nil {
-			return nil, err
+			return nil, externalapi.StatusInvalid, err
 		}
 
 		// Don't set blocks in the anticone of the pruning point as header selected tip.
@@ -125,7 +125,7 @@ func (bp *blockProcessor) validateAndInsertBlock(stagingArea *model.StagingArea,
 		// Don't set blocks in the anticone of the pruning point as header selected tip.
 		err = bp.headerTipsManager.AddHeaderTip(stagingArea, blockHash)
 		if err != nil {
-			return nil, err
+			return nil, externalapi.StatusInvalid, err
 		}
 	}
 
@@ -138,14 +138,14 @@ func (bp *blockProcessor) validateAndInsertBlock(stagingArea *model.StagingArea,
 		// Attempt to add the block to the virtual
 		selectedParentChainChanges, virtualUTXODiff, reversalData, err = bp.consensusStateManager.AddBlock(stagingArea, blockHash, shouldValidateAgainstUTXO)
 		if err != nil {
-			return nil, err
+			return nil, externalapi.StatusInvalid, err
 		}
 	}
 
 	if hasHeaderSelectedTip {
 		err := bp.updateReachabilityReindexRoot(stagingArea, oldHeadersSelectedTip)
 		if err != nil {
-			return nil, err
+			return nil, externalapi.StatusInvalid, err
 		}
 	}
 
@@ -153,25 +153,25 @@ func (bp *blockProcessor) validateAndInsertBlock(stagingArea *model.StagingArea,
 		// Trigger pruning, which will check if the pruning point changed and delete the data if it did.
 		err = bp.pruningManager.UpdatePruningPointByVirtual(stagingArea)
 		if err != nil {
-			return nil, err
+			return nil, externalapi.StatusInvalid, err
 		}
 	}
 
 	err = staging.CommitAllChanges(bp.databaseContext, stagingArea)
 	if err != nil {
-		return nil, err
+		return nil, externalapi.StatusInvalid, err
 	}
 
 	if reversalData != nil {
 		err = bp.consensusStateManager.ReverseUTXODiffs(blockHash, reversalData)
 		if err != nil {
-			return nil, err
+			return nil, externalapi.StatusInvalid, err
 		}
 	}
 
 	err = bp.pruningManager.UpdatePruningPointIfRequired()
 	if err != nil {
-		return nil, err
+		return nil, externalapi.StatusInvalid, err
 	}
 
 	log.Debug(logger.NewLogClosure(func() string {
@@ -196,14 +196,14 @@ func (bp *blockProcessor) validateAndInsertBlock(stagingArea *model.StagingArea,
 			virtualGhostDAGData.BlueScore(), blockCount, headerCount)
 	}))
 	if logClosureErr != nil {
-		return nil, logClosureErr
+		return nil, externalapi.StatusInvalid, logClosureErr
 	}
 
 	virtualParents, err := bp.dagTopologyManager.Parents(stagingArea, model.VirtualBlockHash)
 	if database.IsNotFoundError(err) {
 		virtualParents = nil
 	} else if err != nil {
-		return nil, err
+		return nil, externalapi.StatusInvalid, err
 	}
 
 	bp.pastMedianTimeManager.InvalidateVirtualPastMedianTimeCache()
@@ -214,7 +214,7 @@ func (bp *blockProcessor) validateAndInsertBlock(stagingArea *model.StagingArea,
 		VirtualSelectedParentChainChanges: selectedParentChainChanges,
 		VirtualUTXODiff:                   virtualUTXODiff,
 		VirtualParents:                    virtualParents,
-	}, nil
+	}, status, nil
 }
 
 func (bp *blockProcessor) loadUTXODataForGenesis(stagingArea *model.StagingArea, block *externalapi.DomainBlock) {

domain/consensus/processes/blockprocessor/validate_and_insert_block_test.go

@@ -79,7 +79,7 @@ func TestBlockStatus(t *testing.T) {
 			disqualifiedBlock.Header.PruningPoint(),
 		)
 
-		_, err = tc.ValidateAndInsertBlock(disqualifiedBlock, true)
+		err = tc.ValidateAndInsertBlock(disqualifiedBlock, true)
 		if err != nil {
 			t.Fatalf("ValidateAndInsertBlock: %+v", err)
 		}
@@ -106,7 +106,7 @@ func TestBlockStatus(t *testing.T) {
 			disqualifiedBlock.Header.PruningPoint(),
 		)
 
-		_, err = tc.ValidateAndInsertBlock(invalidBlock, true)
+		err = tc.ValidateAndInsertBlock(invalidBlock, true)
 		if err == nil {
 			t.Fatalf("block is expected to be invalid")
 		}
@@ -139,11 +139,11 @@ func TestValidateAndInsertErrors(t *testing.T) {
 		if err != nil {
 			t.Fatalf("AddBlock: %+v", err)
 		}
-		_, err = tc.ValidateAndInsertBlock(blockWithStatusInvalid, true)
+		err = tc.ValidateAndInsertBlock(blockWithStatusInvalid, true)
 		if err == nil {
 			t.Fatalf("Test ValidateAndInsertBlock: Expected an error, because the block is invalid.")
 		}
-		_, err = tc.ValidateAndInsertBlock(blockWithStatusInvalid, true)
+		err = tc.ValidateAndInsertBlock(blockWithStatusInvalid, true)
 		if err == nil || !errors.Is(err, ruleerrors.ErrKnownInvalid) {
 			t.Fatalf("Expected block to be invalid with err: %v, instead found: %v", ruleerrors.ErrKnownInvalid, err)
 		}
@@ -155,12 +155,12 @@ func TestValidateAndInsertErrors(t *testing.T) {
 		if err != nil {
 			t.Fatalf("AddBlock: %+v", err)
 		}
-		_, err = tc.ValidateAndInsertBlock(block, true)
+		err = tc.ValidateAndInsertBlock(block, true)
 		if err != nil {
 			t.Fatalf("ValidateAndInsertBlock: %+v", err)
 		}
 		// resend the same block.
-		_, err = tc.ValidateAndInsertBlock(block, true)
+		err = tc.ValidateAndInsertBlock(block, true)
 		if err == nil || !errors.Is(err, ruleerrors.ErrDuplicateBlock) {
 			t.Fatalf("Expected block to be invalid with err: %v, instead found: %v", ruleerrors.ErrDuplicateBlock, err)
 		}
@@ -173,12 +173,12 @@ func TestValidateAndInsertErrors(t *testing.T) {
 			t.Fatalf("AddBlock: %+v", err)
 		}
 		onlyHeader.Transactions = []*externalapi.DomainTransaction{}
-		_, err = tc.ValidateAndInsertBlock(onlyHeader, true)
+		err = tc.ValidateAndInsertBlock(onlyHeader, true)
 		if err != nil {
 			t.Fatalf("AddBlock: %+v", err)
 		}
 		// resend the same header.
-		_, err = tc.ValidateAndInsertBlock(onlyHeader, true)
+		err = tc.ValidateAndInsertBlock(onlyHeader, true)
 		if err == nil || !errors.Is(err, ruleerrors.ErrDuplicateBlock) {
 			t.Fatalf("Expected block to be invalid with err: %v, instead found: %v", ruleerrors.ErrDuplicateBlock, err)
 		}

domain/consensus/processes/blockprocessor/validate_and_insert_block_with_trusted_data.go

@@ -8,7 +8,7 @@ import (
 )
 
 func (bp *blockProcessor) validateAndInsertBlockWithTrustedData(stagingArea *model.StagingArea,
-	block *externalapi.BlockWithTrustedData, validateUTXO bool) (*externalapi.VirtualChangeSet, error) {
+	block *externalapi.BlockWithTrustedData, validateUTXO bool) (*externalapi.VirtualChangeSet, externalapi.BlockStatus, error) {
 
 	blockHash := consensushashing.BlockHash(block.Block)
 	for i, daaBlock := range block.DAAWindow {
@@ -22,7 +22,7 @@ func (bp *blockProcessor) validateAndInsertBlockWithTrustedData(stagingArea *mod
 
 	blockReplacedGHOSTDAGData, err := bp.ghostdagDataWithoutPrunedBlocks(stagingArea, block.GHOSTDAGData[0].GHOSTDAGData)
 	if err != nil {
-		return nil, err
+		return nil, externalapi.StatusInvalid, err
 	}
 	bp.ghostdagDataStore.Stage(stagingArea, blockHash, blockReplacedGHOSTDAGData, false)
 

domain/consensus/processes/blockprocessor/validate_and_insert_imported_pruning_point_test.go

@@ -26,7 +26,7 @@ func addBlock(tc testapi.TestConsensus, parentHashes []*externalapi.DomainHash,
 	}
 
 	blockHash := consensushashing.BlockHash(block)
-	_, err = tc.ValidateAndInsertBlock(block, true)
+	err = tc.ValidateAndInsertBlock(block, true)
 	if err != nil {
 		t.Fatalf("ValidateAndInsertBlock: %+v", err)
 	}
@@ -44,7 +44,7 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 		consensusConfig.K = 0
 		consensusConfig.PruningProofM = 1
 
-		syncConsensuses := func(tcSyncerRef, tcSynceeRef *testapi.TestConsensus) {
+		syncConsensuses := func(tcSyncerRef, tcSynceeRef *testapi.TestConsensus, updatePruningPointJustAfterImportingPruningPoint bool) {
 			tcSyncer, tcSyncee := *tcSyncerRef, *tcSynceeRef
 			pruningPointProof, err := tcSyncer.BuildPruningPointProof()
 			if err != nil {
@@ -133,7 +133,7 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 					})
 				}
 
-				_, err = synceeStaging.ValidateAndInsertBlockWithTrustedData(blockWithTrustedData, false)
+				err = synceeStaging.ValidateAndInsertBlockWithTrustedData(blockWithTrustedData, false)
 				if err != nil {
 					t.Fatalf("ValidateAndInsertBlockWithTrustedData: %+v", err)
 				}
@@ -169,7 +169,7 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 					t.Fatalf("GetBlockHeader: %+v", err)
 				}
 
-				_, err = synceeStaging.ValidateAndInsertBlock(&externalapi.DomainBlock{Header: header}, false)
+				err = synceeStaging.ValidateAndInsertBlock(&externalapi.DomainBlock{Header: header}, false)
 				if err != nil {
 					t.Fatalf("ValidateAndInsertBlock %d: %+v", i, err)
 				}
@@ -236,6 +236,13 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 				t.Fatalf("ValidateAndInsertImportedPruningPoint: %+v", err)
 			}
 
+			if updatePruningPointJustAfterImportingPruningPoint {
+				err = synceeStaging.UpdatePruningPointByVirtual()
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+
 			emptyCoinbase := &externalapi.DomainCoinbaseData{
 				ScriptPublicKey: &externalapi.ScriptPublicKey{
 					Script:  nil,
@@ -266,7 +273,7 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 					t.Fatalf("GetBlock: %+v", err)
 				}
 
-				_, err = synceeStaging.ValidateAndInsertBlock(block, true)
+				err = synceeStaging.ValidateAndInsertBlock(block, true)
 				if err != nil {
 					t.Fatalf("ValidateAndInsertBlock: %+v", err)
 				}
@@ -292,7 +299,7 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 				t.Fatalf("GetBlock: %+v", err)
 			}
 
-			_, err = synceeStaging.ValidateAndInsertBlock(tip, true)
+			err = synceeStaging.ValidateAndInsertBlock(tip, true)
 			if err != nil {
 				t.Fatalf("ValidateAndInsertBlock: %+v", err)
 			}
@@ -339,7 +346,7 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 				t.Fatalf("GetBlock: %+v", err)
 			}
 
-			_, err = tcSyncee1.ValidateAndInsertBlock(block, true)
+			err = tcSyncee1.ValidateAndInsertBlock(block, true)
 			if err != nil {
 				t.Fatalf("ValidateAndInsertBlock: %+v", err)
 			}
@@ -386,7 +393,7 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 		}
 
 		tcSyncee1Ref := &tcSyncee1
-		syncConsensuses(&tcSyncer, tcSyncee1Ref)
+		syncConsensuses(&tcSyncer, tcSyncee1Ref, false)
 
 		// Test a situation where a consensus with pruned headers syncs another fresh consensus.
 		tcSyncee2, teardownSyncee2, err := factory.NewTestConsensus(consensusConfig, "TestValidateAndInsertPruningPointSyncee2")
@@ -395,7 +402,17 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 		}
 		defer teardownSyncee2(false)
 
-		syncConsensuses(tcSyncee1Ref, &tcSyncee2)
+		syncConsensuses(tcSyncee1Ref, &tcSyncee2, false)
+
+		// Check the regular sync but try to update the pruning point after the pruning point was imported. It tests a situation where the node
+		// was restarted before the virtual was resolved and then it calls UpdatePruningPointByVirtual on init.
+		tcSyncee3, teardownSyncee3, err := factory.NewTestConsensus(consensusConfig, "TestValidateAndInsertPruningPointSyncee3")
+		if err != nil {
+			t.Fatalf("Error setting up tcSyncee1: %+v", err)
+		}
+		defer teardownSyncee3(false)
+
+		syncConsensuses(&tcSyncer, &tcSyncee3, true)
 	})
 }
 
@@ -461,7 +478,7 @@ func TestGetPruningPointUTXOs(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Error building block above genesis: %+v", err)
 		}
-		_, err = testConsensus.ValidateAndInsertBlock(blockAboveGenesis, true)
+		err = testConsensus.ValidateAndInsertBlock(blockAboveGenesis, true)
 		if err != nil {
 			t.Fatalf("Error validating and inserting block above genesis: %+v", err)
 		}
@@ -473,7 +490,7 @@ func TestGetPruningPointUTXOs(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Error building block with spendable coinbase: %+v", err)
 		}
-		_, err = testConsensus.ValidateAndInsertBlock(blockWithSpendableCoinbase, true)
+		err = testConsensus.ValidateAndInsertBlock(blockWithSpendableCoinbase, true)
 		if err != nil {
 			t.Fatalf("Error validating and inserting block with spendable coinbase: %+v", err)
 		}
@@ -512,7 +529,7 @@ func TestGetPruningPointUTXOs(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Error building including block: %+v", err)
 		}
-		_, err = testConsensus.ValidateAndInsertBlock(includingBlock, true)
+		err = testConsensus.ValidateAndInsertBlock(includingBlock, true)
 		if err != nil {
 			t.Fatalf("Error validating and inserting including block: %+v", err)
 		}
@@ -523,7 +540,7 @@ func TestGetPruningPointUTXOs(t *testing.T) {
 			if err != nil {
 				t.Fatalf("Error building block: %+v", err)
 			}
-			_, err = testConsensus.ValidateAndInsertBlock(block, true)
+			err = testConsensus.ValidateAndInsertBlock(block, true)
 			if err != nil {
 				t.Fatalf("Error validating and inserting block: %+v", err)
 			}
@@ -619,7 +636,7 @@ func BenchmarkGetPruningPointUTXOs(b *testing.B) {
 	if err != nil {
 		b.Fatalf("Error building block with spendable coinbase: %+v", err)
 	}
-	_, err = testConsensus.ValidateAndInsertBlock(blockWithSpendableCoinbase, true)
+	err = testConsensus.ValidateAndInsertBlock(blockWithSpendableCoinbase, true)
 	if err != nil {
 		b.Fatalf("Error validating and inserting block with spendable coinbase: %+v", err)
 	}
@@ -657,7 +674,7 @@ func BenchmarkGetPruningPointUTXOs(b *testing.B) {
 		if err != nil {
 			b.Fatalf("Error building block: %+v", err)
 		}
-		_, err = testConsensus.ValidateAndInsertBlock(block, true)
+		err = testConsensus.ValidateAndInsertBlock(block, true)
 		if err != nil {
 			b.Fatalf("Error validating and inserting block: %+v", err)
 		}
@@ -677,7 +694,7 @@ func BenchmarkGetPruningPointUTXOs(b *testing.B) {
 		if err != nil {
 			b.Fatalf("Error building block: %+v", err)
 		}
-		_, err = testConsensus.ValidateAndInsertBlock(block, true)
+		err = testConsensus.ValidateAndInsertBlock(block, true)
 		if err != nil {
 			b.Fatalf("Error validating and inserting block: %+v", err)
 		}

domain/consensus/processes/blockvalidator/block_body_in_context_test.go

@@ -62,7 +62,7 @@ func TestCheckBlockIsNotPruned(t *testing.T) {
 			}
 		}
 
-		_, err = tc.ValidateAndInsertBlock(beforePruningBlock, true)
+		err = tc.ValidateAndInsertBlock(beforePruningBlock, true)
 		if !errors.Is(err, ruleerrors.ErrPrunedBlock) {
 			t.Fatalf("Unexpected error: %+v", err)
 		}
@@ -117,7 +117,7 @@ func TestCheckParentBlockBodiesExist(t *testing.T) {
 		}
 
 		// Add only the header of anticonePruningBlock
-		_, err = tc.ValidateAndInsertBlock(&externalapi.DomainBlock{
+		err = tc.ValidateAndInsertBlock(&externalapi.DomainBlock{
 			Header:       anticonePruningBlock.Header,
 			Transactions: nil,
 		}, true)
@@ -143,7 +143,7 @@ func TestCheckParentBlockBodiesExist(t *testing.T) {
 
 		// Add anticonePruningBlock's body and check that it's valid to point to
 		// a header only block in the past of the pruning point.
-		_, err = tc.ValidateAndInsertBlock(anticonePruningBlock, true)
+		err = tc.ValidateAndInsertBlock(anticonePruningBlock, true)
 		if err != nil {
 			t.Fatalf("ValidateAndInsertBlock: %+v", err)
 		}
@@ -189,7 +189,7 @@ func TestIsFinalizedTransaction(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Error getting block: %+v", err)
 		}
-		_, err = tc.ValidateAndInsertBlock(block, true)
+		err = tc.ValidateAndInsertBlock(block, true)
 		if err != nil {
 			t.Fatalf("Error Inserting block: %+v", err)
 		}

domain/consensus/processes/blockvalidator/block_body_in_isolation.go

@@ -140,7 +140,7 @@ func (v *blockValidator) checkBlockTransactionOrder(block *externalapi.DomainBlo
 
 func (v *blockValidator) checkTransactionsInIsolation(block *externalapi.DomainBlock) error {
 	for _, tx := range block.Transactions {
-		err := v.transactionValidator.ValidateTransactionInIsolation(tx)
+		err := v.transactionValidator.ValidateTransactionInIsolation(tx, block.Header.DAAScore())
 		if err != nil {
 			return errors.Wrapf(err, "transaction %s failed isolation "+
 				"check", consensushashing.TransactionID(tx))
@@ -220,10 +220,6 @@ func (v *blockValidator) validateGasLimit(block *externalapi.DomainBlock) error
 
 func (v *blockValidator) checkBlockMass(block *externalapi.DomainBlock) error {
 	mass := uint64(0)
-	if !v.ignoreHeaderMass {
-		mass += v.headerEstimatedSerializedSize(block.Header)
-	}
-
 	for _, transaction := range block.Transactions {
 		v.transactionValidator.PopulateMass(transaction)