go test race detector in github actions at cron job (#1534)

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

.codecov.yml

@@ -0,0 +1,9 @@
+coverage:
+  status:
+    patch: off
+
+    project:
+      default:
+        informational: true
+ignore:
+  - "**/*.pb.go" # Ignore all auto generated protobuf structures.

.github/workflows/go-race.yml

@@ -0,0 +1,48 @@
+name: Go-Race
+
+on:
+  schedule:
+    - cron: "0 0 * * *"
+  workflow_dispatch:
+
+jobs:
+  race_test:
+    runs-on: ubuntu-20.04
+    strategy:
+      matrix:
+        branch: [ master, latest ]
+    name: Race detection on ${{ matrix.branch }}
+    steps:
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go 1.x
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.15
+
+      - name: Set scheduled branch name
+        shell: bash
+        if: github.event_name == 'schedule'
+        run: |
+          if [ "${{ matrix.branch }}" == "master" ]; then
+            echo "run_on=master" >> $GITHUB_ENV
+          fi
+          if [ "${{ matrix.branch }}" == "latest" ]; then
+            branch=$(git branch -r | grep 'v\([0-9]\+\.\)\([0-9]\+\.\)\([0-9]\+\)-dev' | sort -Vr | head -1 | xargs)
+            echo "run_on=${branch}" >> $GITHUB_ENV
+          fi
+
+      - name: Set manual branch name
+        shell: bash
+        if: github.event_name == 'workflow_dispatch'
+        run: echo "run_on=${{ github.ref }}" >> $GITHUB_ENV
+
+      - name: Test with race detector
+        shell: bash
+        run: |
+          git checkout "${{ env.run_on }}"
+          git status
+          go test -race ./...

.github/workflows/go.yml

@@ -34,7 +34,7 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v2
         with:
-          go-version: 1.14
+          go-version: 1.15
 
 
       # Source: https://github.com/actions/cache/blob/main/examples.md#go---modules
@@ -49,3 +49,21 @@ jobs:
       - name: Test
         shell: bash
         run: ./build_and_test.sh
+
+  coverage:
+    runs-on: ubuntu-20.04
+    name: Produce code coverage
+    steps:
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Set up Go 1.x
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.15
+
+      - name: Create coverage file
+        run: go test -covermode=atomic -coverpkg=./... -coverprofile coverage.txt ./...
+
+      - name: Upload coverage file
+        run: bash <(curl -s https://codecov.io/bash)

CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# Contributing to Kaspad
+
+Any contribution to Kaspad is very welcome.
+
+## Getting started
+
+If you want to start contributing to Kaspad and don't know where to start, you can pick an issue from
+the [list](https://github.com/kaspanet/kaspad/issues).
+
+If you want to make a big change it's better to discuss it first by opening an issue or talk about it in
+[Discord](https://discord.gg/WmGhhzk) to avoid duplicate work.
+
+## Pull Request process
+
+Any pull request should be opened against the development branch of the target version. The development branch format is
+as follows: `vx.y.z-dev`, for example: `v0.8.5-dev`.
+
+All pull requests should pass the checks written in `build_and_test.sh`, so it's recommended to run this script before
+submitting your PR.

README.md

@@ -9,12 +9,16 @@ Warning: This is pre-alpha software. There's no guarantee anything works.
 
 Kaspad is the reference full node Kaspa implementation written in Go (golang).
 
-This project is currently under active development and is in a pre-Alpha state. 
+This project is currently under active development and is in a pre-Alpha state.
 Some things still don't work and APIs are far from finalized. The code is provided for reference only.
 
+## What is kaspa
+
+Kaspa is an attempt at a proof-of-work cryptocurrency with instant confirmations and sub-second block times. It is based on [the PHANTOM protocol](https://eprint.iacr.org/2018/104.pdf), a generalization of Nakamoto consensus.
+
 ## Requirements
 
-Latest version of [Go](http://golang.org) (currently 1.13).
+Go 1.15 or later.
 
 ## Installation
 
@@ -27,23 +31,17 @@ Latest version of [Go](http://golang.org) (currently 1.13).
 
 ```bash
 $ go version
-$ go env GOROOT GOPATH
 ```
 
-NOTE: The `GOROOT` and `GOPATH` above must not be the same path. It is
-recommended that `GOPATH` is set to a directory in your home directory such as
-`~/dev/go` to avoid write permission issues. It is also recommended to add
-`$GOPATH/bin` to your `PATH` at this point.
-
 - Run the following commands to obtain and install kaspad including all dependencies:
 
 ```bash
-$ git clone https://github.com/kaspanet/kaspad $GOPATH/src/github.com/kaspanet/kaspad
-$ cd $GOPATH/src/github.com/kaspanet/kaspad
+$ git clone https://github.com/kaspanet/kaspad
+$ cd kaspad
 $ go install . ./cmd/...
 ```
 
-- Kaspad (and utilities) should now be installed in `$GOPATH/bin`. If you did
+- Kaspad (and utilities) should now be installed in `$(go env GOPATH)/bin`. If you did
   not already add the bin directory to your system path during Go installation,
   you are encouraged to do so now.
 
@@ -53,10 +51,8 @@ $ go install . ./cmd/...
 Kaspad has several configuration options available to tweak how it runs, but all
 of the basic operations work with zero configuration.
 
-#### Linux/BSD/POSIX/Source
-
 ```bash
-$ ./kaspad
+$ kaspad
 ```
 
 ## Discord
@@ -69,9 +65,8 @@ is used for this project.
 
 ## Documentation
 
-The documentation is a work-in-progress. It is located in the [docs](https://github.com/kaspanet/kaspad/tree/master/docs) folder.
+The [documentation](https://github.com/kaspanet/docs) is a work-in-progress
 
 ## License
 
 Kaspad is licensed under the copyfree [ISC License](https://choosealicense.com/licenses/isc/).
-

app/app.go

@@ -22,6 +22,8 @@ import (
 	"github.com/kaspanet/kaspad/infrastructure/os/winservice"
 )
 
+const leveldbCacheSizeMiB = 256
+
 var desiredLimits = &limits.DesiredLimits{
 	FileLimitWant: 2048,
 	FileLimitMin:  1024,
@@ -181,5 +183,5 @@ func removeDatabase(cfg *config.Config) error {
 func openDB(cfg *config.Config) (database.Database, error) {
 	dbPath := databasePath(cfg)
 	log.Infof("Loading database from '%s'", dbPath)
-	return ldb.NewLevelDB(dbPath)
+	return ldb.NewLevelDB(dbPath, leveldbCacheSizeMiB)
 }

app/appmessage/domainconverters.go

@@ -3,6 +3,7 @@ package appmessage
 import (
 	"encoding/hex"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/blockheader"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
@@ -268,3 +269,49 @@ func DomainTransactionToRPCTransaction(transaction *externalapi.DomainTransactio
 		Payload:      payload,
 	}
 }
+
+// OutpointAndUTXOEntryPairsToDomainOutpointAndUTXOEntryPairs converts
+// OutpointAndUTXOEntryPairs to domain OutpointAndUTXOEntryPairs
+func OutpointAndUTXOEntryPairsToDomainOutpointAndUTXOEntryPairs(
+	outpointAndUTXOEntryPairs []*OutpointAndUTXOEntryPair) []*externalapi.OutpointAndUTXOEntryPair {
+
+	domainOutpointAndUTXOEntryPairs := make([]*externalapi.OutpointAndUTXOEntryPair, len(outpointAndUTXOEntryPairs))
+	for i, outpointAndUTXOEntryPair := range outpointAndUTXOEntryPairs {
+		domainOutpointAndUTXOEntryPairs[i] = &externalapi.OutpointAndUTXOEntryPair{
+			Outpoint: &externalapi.DomainOutpoint{
+				TransactionID: outpointAndUTXOEntryPair.Outpoint.TxID,
+				Index:         outpointAndUTXOEntryPair.Outpoint.Index,
+			},
+			UTXOEntry: utxo.NewUTXOEntry(
+				outpointAndUTXOEntryPair.UTXOEntry.Amount,
+				outpointAndUTXOEntryPair.UTXOEntry.ScriptPublicKey,
+				outpointAndUTXOEntryPair.UTXOEntry.IsCoinbase,
+				outpointAndUTXOEntryPair.UTXOEntry.BlockBlueScore,
+			),
+		}
+	}
+	return domainOutpointAndUTXOEntryPairs
+}
+
+// DomainOutpointAndUTXOEntryPairsToOutpointAndUTXOEntryPairs converts
+// domain OutpointAndUTXOEntryPairs to OutpointAndUTXOEntryPairs
+func DomainOutpointAndUTXOEntryPairsToOutpointAndUTXOEntryPairs(
+	outpointAndUTXOEntryPairs []*externalapi.OutpointAndUTXOEntryPair) []*OutpointAndUTXOEntryPair {
+
+	domainOutpointAndUTXOEntryPairs := make([]*OutpointAndUTXOEntryPair, len(outpointAndUTXOEntryPairs))
+	for i, outpointAndUTXOEntryPair := range outpointAndUTXOEntryPairs {
+		domainOutpointAndUTXOEntryPairs[i] = &OutpointAndUTXOEntryPair{
+			Outpoint: &Outpoint{
+				TxID:  outpointAndUTXOEntryPair.Outpoint.TransactionID,
+				Index: outpointAndUTXOEntryPair.Outpoint.Index,
+			},
+			UTXOEntry: &UTXOEntry{
+				Amount:          outpointAndUTXOEntryPair.UTXOEntry.Amount(),
+				ScriptPublicKey: outpointAndUTXOEntryPair.UTXOEntry.ScriptPublicKey(),
+				IsCoinbase:      outpointAndUTXOEntryPair.UTXOEntry.IsCoinbase(),
+				BlockBlueScore:  outpointAndUTXOEntryPair.UTXOEntry.BlockBlueScore(),
+			},
+		}
+	}
+	return domainOutpointAndUTXOEntryPairs
+}

app/appmessage/message.go

@@ -51,15 +51,18 @@ const (
 	CmdReject
 	CmdHeader
 	CmdRequestNextHeaders
-	CmdRequestIBDRootUTXOSetAndBlock
-	CmdIBDRootUTXOSetAndBlock
+	CmdRequestPruningPointUTXOSetAndBlock
+	CmdPruningPointUTXOSetChunk
 	CmdRequestIBDBlocks
-	CmdIBDRootNotFound
-	CmdRequestIBDRootHash
-	CmdIBDRootHash
+	CmdUnexpectedPruningPoint
+	CmdRequestPruningPointHash
+	CmdPruningPointHash
 	CmdIBDBlockLocator
 	CmdIBDBlockLocatorHighestHash
+	CmdIBDBlockLocatorHighestHashNotFound
 	CmdBlockHeaders
+	CmdRequestNextPruningPointUTXOSetChunk
+	CmdDonePruningPointUTXOSetChunks
 
 	// rpc
 	CmdGetCurrentNetworkRequestMessage
@@ -114,6 +117,8 @@ const (
 	CmdNotifyUTXOsChangedRequestMessage
 	CmdNotifyUTXOsChangedResponseMessage
 	CmdUTXOsChangedNotificationMessage
+	CmdStopNotifyingUTXOsChangedRequestMessage
+	CmdStopNotifyingUTXOsChangedResponseMessage
 	CmdGetUTXOsByAddressesRequestMessage
 	CmdGetUTXOsByAddressesResponseMessage
 	CmdGetVirtualSelectedParentBlueScoreRequestMessage
@@ -121,40 +126,49 @@ const (
 	CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage
 	CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage
 	CmdVirtualSelectedParentBlueScoreChangedNotificationMessage
+	CmdBanRequestMessage
+	CmdBanResponseMessage
+	CmdUnbanRequestMessage
+	CmdUnbanResponseMessage
+	CmdGetInfoRequestMessage
+	CmdGetInfoResponseMessage
 )
 
 // ProtocolMessageCommandToString maps all MessageCommands to their string representation
 var ProtocolMessageCommandToString = map[MessageCommand]string{
-	CmdVersion:                       "Version",
-	CmdVerAck:                        "VerAck",
-	CmdRequestAddresses:              "RequestAddresses",
-	CmdAddresses:                     "Addresses",
-	CmdRequestHeaders:                "RequestHeaders",
-	CmdBlock:                         "Block",
-	CmdTx:                            "Tx",
-	CmdPing:                          "Ping",
-	CmdPong:                          "Pong",
-	CmdRequestBlockLocator:           "RequestBlockLocator",
-	CmdBlockLocator:                  "BlockLocator",
-	CmdInvRelayBlock:                 "InvRelayBlock",
-	CmdRequestRelayBlocks:            "RequestRelayBlocks",
-	CmdInvTransaction:                "InvTransaction",
-	CmdRequestTransactions:           "RequestTransactions",
-	CmdIBDBlock:                      "IBDBlock",
-	CmdDoneHeaders:                   "DoneHeaders",
-	CmdTransactionNotFound:           "TransactionNotFound",
-	CmdReject:                        "Reject",
-	CmdHeader:                        "Header",
-	CmdRequestNextHeaders:            "RequestNextHeaders",
-	CmdRequestIBDRootUTXOSetAndBlock: "RequestPruningUTXOSetAndBlock",
-	CmdIBDRootUTXOSetAndBlock:        "IBDRootUTXOSetAndBlock",
-	CmdRequestIBDBlocks:              "RequestIBDBlocks",
-	CmdIBDRootNotFound:               "IBDRootNotFound",
-	CmdRequestIBDRootHash:            "IBDRequestIBDRootHash",
-	CmdIBDRootHash:                   "IBDIBDRootHash",
-	CmdIBDBlockLocator:               "IBDBlockLocator",
-	CmdIBDBlockLocatorHighestHash:    "IBDBlockLocatorHighestHash",
-	CmdBlockHeaders:                  "BlockHeaders",
+	CmdVersion:                             "Version",
+	CmdVerAck:                              "VerAck",
+	CmdRequestAddresses:                    "RequestAddresses",
+	CmdAddresses:                           "Addresses",
+	CmdRequestHeaders:                      "RequestHeaders",
+	CmdBlock:                               "Block",
+	CmdTx:                                  "Tx",
+	CmdPing:                                "Ping",
+	CmdPong:                                "Pong",
+	CmdRequestBlockLocator:                 "RequestBlockLocator",
+	CmdBlockLocator:                        "BlockLocator",
+	CmdInvRelayBlock:                       "InvRelayBlock",
+	CmdRequestRelayBlocks:                  "RequestRelayBlocks",
+	CmdInvTransaction:                      "InvTransaction",
+	CmdRequestTransactions:                 "RequestTransactions",
+	CmdIBDBlock:                            "IBDBlock",
+	CmdDoneHeaders:                         "DoneHeaders",
+	CmdTransactionNotFound:                 "TransactionNotFound",
+	CmdReject:                              "Reject",
+	CmdHeader:                              "Header",
+	CmdRequestNextHeaders:                  "RequestNextHeaders",
+	CmdRequestPruningPointUTXOSetAndBlock:  "RequestPruningPointUTXOSetAndBlock",
+	CmdPruningPointUTXOSetChunk:            "PruningPointUTXOSetChunk",
+	CmdRequestIBDBlocks:                    "RequestIBDBlocks",
+	CmdUnexpectedPruningPoint:              "UnexpectedPruningPoint",
+	CmdRequestPruningPointHash:             "RequestPruningPointHashHash",
+	CmdPruningPointHash:                    "PruningPointHash",
+	CmdIBDBlockLocator:                     "IBDBlockLocator",
+	CmdIBDBlockLocatorHighestHash:          "IBDBlockLocatorHighestHash",
+	CmdIBDBlockLocatorHighestHashNotFound:  "IBDBlockLocatorHighestHashNotFound",
+	CmdBlockHeaders:                        "BlockHeaders",
+	CmdRequestNextPruningPointUTXOSetChunk: "RequestNextPruningPointUTXOSetChunk",
+	CmdDonePruningPointUTXOSetChunks:       "DonePruningPointUTXOSetChunks",
 }
 
 // RPCMessageCommandToString maps all MessageCommands to their string representation
@@ -209,6 +223,8 @@ var RPCMessageCommandToString = map[MessageCommand]string{
 	CmdNotifyUTXOsChangedRequestMessage:                           "NotifyUTXOsChangedRequest",
 	CmdNotifyUTXOsChangedResponseMessage:                          "NotifyUTXOsChangedResponse",
 	CmdUTXOsChangedNotificationMessage:                            "UTXOsChangedNotification",
+	CmdStopNotifyingUTXOsChangedRequestMessage:                    "StopNotifyingUTXOsChangedRequest",
+	CmdStopNotifyingUTXOsChangedResponseMessage:                   "StopNotifyingUTXOsChangedResponse",
 	CmdGetUTXOsByAddressesRequestMessage:                          "GetUTXOsByAddressesRequest",
 	CmdGetUTXOsByAddressesResponseMessage:                         "GetUTXOsByAddressesResponse",
 	CmdGetVirtualSelectedParentBlueScoreRequestMessage:            "GetVirtualSelectedParentBlueScoreRequest",
@@ -216,6 +232,12 @@ var RPCMessageCommandToString = map[MessageCommand]string{
 	CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage:  "NotifyVirtualSelectedParentBlueScoreChangedRequest",
 	CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage: "NotifyVirtualSelectedParentBlueScoreChangedResponse",
 	CmdVirtualSelectedParentBlueScoreChangedNotificationMessage:   "VirtualSelectedParentBlueScoreChangedNotification",
+	CmdBanRequestMessage:                                          "BanRequest",
+	CmdBanResponseMessage:                                         "BanResponse",
+	CmdUnbanRequestMessage:                                        "UnbanRequest",
+	CmdUnbanResponseMessage:                                       "UnbanResponse",
+	CmdGetInfoRequestMessage:                                      "GetInfoRequestMessage",
+	CmdGetInfoResponseMessage:                                     "GeInfoResponseMessage",
 }
 
 // Message is an interface that describes a kaspa message. A type that

app/appmessage/p2p_ibdrootnotfound.go

@@ -1,22 +0,0 @@
-package appmessage
-
-// MsgIBDRootNotFound implements the Message interface and represents a kaspa
-// IBDRootNotFound message. It is used to notify the IBD root that was requested
-// by other peer was not found.
-//
-// This message has no payload.
-type MsgIBDRootNotFound struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgIBDRootNotFound) Command() MessageCommand {
-	return CmdIBDRootNotFound
-}
-
-// NewMsgIBDRootNotFound returns a new kaspa IBDRootNotFound message that conforms to the
-// Message interface.
-func NewMsgIBDRootNotFound() *MsgIBDRootNotFound {
-	return &MsgIBDRootNotFound{}
-}

app/appmessage/p2p_msgblockheader_test.go

@@ -11,15 +11,11 @@ import (
 	"github.com/davecgh/go-spew/spew"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/util/mstime"
-	"github.com/kaspanet/kaspad/util/random"
 )
 
 // TestBlockHeader tests the MsgBlockHeader API.
 func TestBlockHeader(t *testing.T) {
-	nonce, err := random.Uint64()
-	if err != nil {
-		t.Errorf("random.Uint64: Error generating nonce: %v", err)
-	}
+	nonce := uint64(0xba4d87a69924a93d)
 
 	hashes := []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash}
 

app/appmessage/p2p_msgdonepruningpointutxosetchunks.go

@@ -0,0 +1,16 @@
+package appmessage
+
+// MsgDonePruningPointUTXOSetChunks represents a kaspa DonePruningPointUTXOSetChunks message
+type MsgDonePruningPointUTXOSetChunks struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgDonePruningPointUTXOSetChunks) Command() MessageCommand {
+	return CmdDonePruningPointUTXOSetChunks
+}
+
+// NewMsgDonePruningPointUTXOSetChunks returns a new MsgDonePruningPointUTXOSetChunks.
+func NewMsgDonePruningPointUTXOSetChunks() *MsgDonePruningPointUTXOSetChunks {
+	return &MsgDonePruningPointUTXOSetChunks{}
+}

app/appmessage/p2p_msgibdblocklocatorhighesthashnotfound.go

@@ -0,0 +1,16 @@
+package appmessage
+
+// MsgIBDBlockLocatorHighestHashNotFound represents a kaspa BlockLocatorHighestHashNotFound message
+type MsgIBDBlockLocatorHighestHashNotFound struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgIBDBlockLocatorHighestHashNotFound) Command() MessageCommand {
+	return CmdIBDBlockLocatorHighestHashNotFound
+}
+
+// NewMsgIBDBlockLocatorHighestHashNotFound returns a new IBDBlockLocatorHighestHashNotFound message
+func NewMsgIBDBlockLocatorHighestHashNotFound() *MsgIBDBlockLocatorHighestHashNotFound {
+	return &MsgIBDBlockLocatorHighestHashNotFound{}
+}

app/appmessage/p2p_msgibdroothash.go

@@ -1,26 +0,0 @@
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// MsgIBDRootHashMessage implements the Message interface and represents a kaspa
-// IBDRootHash message. It is used as a reply to IBD root hash requests.
-type MsgIBDRootHashMessage struct {
-	baseMessage
-	Hash *externalapi.DomainHash
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgIBDRootHashMessage) Command() MessageCommand {
-	return CmdIBDRootHash
-}
-
-// NewMsgIBDRootHashMessage returns a new kaspa IBDRootHash message that conforms to
-// the Message interface. See MsgIBDRootHashMessage for details.
-func NewMsgIBDRootHashMessage(hash *externalapi.DomainHash) *MsgIBDRootHashMessage {
-	return &MsgIBDRootHashMessage{
-		Hash: hash,
-	}
-}

app/appmessage/p2p_msgibdrootutxosetandblock.go

@@ -1,23 +0,0 @@
-package appmessage
-
-// MsgIBDRootUTXOSetAndBlock implements the Message interface and represents a kaspa
-// IBDRootUTXOSetAndBlock message. It is used to answer RequestIBDRootUTXOSetAndBlock messages.
-type MsgIBDRootUTXOSetAndBlock struct {
-	baseMessage
-	UTXOSet []byte
-	Block   *MsgBlock
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgIBDRootUTXOSetAndBlock) Command() MessageCommand {
-	return CmdIBDRootUTXOSetAndBlock
-}
-
-// NewMsgIBDRootUTXOSetAndBlock returns a new MsgIBDRootUTXOSetAndBlock.
-func NewMsgIBDRootUTXOSetAndBlock(utxoSet []byte, block *MsgBlock) *MsgIBDRootUTXOSetAndBlock {
-	return &MsgIBDRootUTXOSetAndBlock{
-		UTXOSet: utxoSet,
-		Block:   block,
-	}
-}

app/appmessage/p2p_msgping_test.go

@@ -6,17 +6,12 @@ package appmessage
 
 import (
 	"testing"
-
-	"github.com/kaspanet/kaspad/util/random"
 )
 
 // TestPing tests the MsgPing API against the latest protocol version.
 func TestPing(t *testing.T) {
 	// Ensure we get the same nonce back out.
-	nonce, err := random.Uint64()
-	if err != nil {
-		t.Errorf("random.Uint64: Error generating nonce: %v", err)
-	}
+	nonce := uint64(0x61c2c5535902862)
 	msg := NewMsgPing(nonce)
 	if msg.Nonce != nonce {
 		t.Errorf("NewMsgPing: wrong nonce - got %v, want %v",

app/appmessage/p2p_msgpong_test.go

@@ -6,16 +6,11 @@ package appmessage
 
 import (
 	"testing"
-
-	"github.com/kaspanet/kaspad/util/random"
 )
 
 // TestPongLatest tests the MsgPong API against the latest protocol version.
 func TestPongLatest(t *testing.T) {
-	nonce, err := random.Uint64()
-	if err != nil {
-		t.Errorf("random.Uint64: error generating nonce: %v", err)
-	}
+	nonce := uint64(0x1a05b581a5182c)
 	msg := NewMsgPong(nonce)
 	if msg.Nonce != nonce {
 		t.Errorf("NewMsgPong: wrong nonce - got %v, want %v",

app/appmessage/p2p_msgpruningpointhash.go

@@ -0,0 +1,23 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MsgPruningPointHashMessage represents a kaspa PruningPointHash message
+type MsgPruningPointHashMessage struct {
+	baseMessage
+	Hash *externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgPruningPointHashMessage) Command() MessageCommand {
+	return CmdPruningPointHash
+}
+
+// NewPruningPointHashMessage returns a new kaspa PruningPointHash message
+func NewPruningPointHashMessage(hash *externalapi.DomainHash) *MsgPruningPointHashMessage {
+	return &MsgPruningPointHashMessage{
+		Hash: hash,
+	}
+}

app/appmessage/p2p_msgpruningpointutxosetchunk.go

@@ -0,0 +1,36 @@
+package appmessage
+
+import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
+// MsgPruningPointUTXOSetChunk represents a kaspa PruningPointUTXOSetChunk message
+type MsgPruningPointUTXOSetChunk struct {
+	baseMessage
+	OutpointAndUTXOEntryPairs []*OutpointAndUTXOEntryPair
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgPruningPointUTXOSetChunk) Command() MessageCommand {
+	return CmdPruningPointUTXOSetChunk
+}
+
+// NewMsgPruningPointUTXOSetChunk returns a new MsgPruningPointUTXOSetChunk.
+func NewMsgPruningPointUTXOSetChunk(outpointAndUTXOEntryPairs []*OutpointAndUTXOEntryPair) *MsgPruningPointUTXOSetChunk {
+	return &MsgPruningPointUTXOSetChunk{
+		OutpointAndUTXOEntryPairs: outpointAndUTXOEntryPairs,
+	}
+}
+
+// OutpointAndUTXOEntryPair is an outpoint along with its
+// respective UTXO entry
+type OutpointAndUTXOEntryPair struct {
+	Outpoint  *Outpoint
+	UTXOEntry *UTXOEntry
+}
+
+// UTXOEntry houses details about an individual transaction output in a UTXO
+type UTXOEntry struct {
+	Amount          uint64
+	ScriptPublicKey *externalapi.ScriptPublicKey
+	BlockBlueScore  uint64
+	IsCoinbase      bool
+}

app/appmessage/p2p_msgrequestibdrootutxosetandblock.go

@@ -1,26 +0,0 @@
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// MsgRequestIBDRootUTXOSetAndBlock implements the Message interface and represents a kaspa
-// RequestIBDRootUTXOSetAndBlock message. It is used to request the UTXO set and block body
-// of the IBD root block.
-type MsgRequestIBDRootUTXOSetAndBlock struct {
-	baseMessage
-	IBDRoot *externalapi.DomainHash
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgRequestIBDRootUTXOSetAndBlock) Command() MessageCommand {
-	return CmdRequestIBDRootUTXOSetAndBlock
-}
-
-// NewMsgRequestIBDRootUTXOSetAndBlock returns a new MsgRequestIBDRootUTXOSetAndBlock.
-func NewMsgRequestIBDRootUTXOSetAndBlock(ibdRoot *externalapi.DomainHash) *MsgRequestIBDRootUTXOSetAndBlock {
-	return &MsgRequestIBDRootUTXOSetAndBlock{
-		IBDRoot: ibdRoot,
-	}
-}

app/appmessage/p2p_msgrequestnextpruningpointutxosetchunk.go

@@ -0,0 +1,16 @@
+package appmessage
+
+// MsgRequestNextPruningPointUTXOSetChunk represents a kaspa RequestNextPruningPointUTXOSetChunk message
+type MsgRequestNextPruningPointUTXOSetChunk struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgRequestNextPruningPointUTXOSetChunk) Command() MessageCommand {
+	return CmdRequestNextPruningPointUTXOSetChunk
+}
+
+// NewMsgRequestNextPruningPointUTXOSetChunk returns a new MsgRequestNextPruningPointUTXOSetChunk.
+func NewMsgRequestNextPruningPointUTXOSetChunk() *MsgRequestNextPruningPointUTXOSetChunk {
+	return &MsgRequestNextPruningPointUTXOSetChunk{}
+}

app/appmessage/p2p_msgrequestpruningpointutxosetandblock.go

@@ -0,0 +1,23 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MsgRequestPruningPointUTXOSetAndBlock represents a kaspa RequestPruningPointUTXOSetAndBlock message
+type MsgRequestPruningPointUTXOSetAndBlock struct {
+	baseMessage
+	PruningPointHash *externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgRequestPruningPointUTXOSetAndBlock) Command() MessageCommand {
+	return CmdRequestPruningPointUTXOSetAndBlock
+}
+
+// NewMsgRequestPruningPointUTXOSetAndBlock returns a new MsgRequestPruningPointUTXOSetAndBlock
+func NewMsgRequestPruningPointUTXOSetAndBlock(pruningPointHash *externalapi.DomainHash) *MsgRequestPruningPointUTXOSetAndBlock {
+	return &MsgRequestPruningPointUTXOSetAndBlock{
+		PruningPointHash: pruningPointHash,
+	}
+}

app/appmessage/p2p_requestibdroothash.go

@@ -1,22 +0,0 @@
-package appmessage
-
-// MsgRequestIBDRootHashMessage implements the Message interface and represents a kaspa
-// MsgRequestIBDRootHashMessage message. It is used to request the IBD root hash
-// from a peer during IBD.
-//
-// This message has no payload.
-type MsgRequestIBDRootHashMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgRequestIBDRootHashMessage) Command() MessageCommand {
-	return CmdRequestIBDRootHash
-}
-
-// NewMsgRequestIBDRootHashMessage returns a new kaspa RequestIBDRootHash message that conforms to the
-// Message interface.
-func NewMsgRequestIBDRootHashMessage() *MsgRequestIBDRootHashMessage {
-	return &MsgRequestIBDRootHashMessage{}
-}

app/appmessage/p2p_requestpruningpointhash.go

@@ -0,0 +1,16 @@
+package appmessage
+
+// MsgRequestPruningPointHashMessage represents a kaspa RequestPruningPointHashMessage message
+type MsgRequestPruningPointHashMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgRequestPruningPointHashMessage) Command() MessageCommand {
+	return CmdRequestPruningPointHash
+}
+
+// NewMsgRequestPruningPointHashMessage returns a new kaspa RequestPruningPointHash message
+func NewMsgRequestPruningPointHashMessage() *MsgRequestPruningPointHashMessage {
+	return &MsgRequestPruningPointHashMessage{}
+}

app/appmessage/p2p_unexpectedpruningpoint.go

@@ -0,0 +1,16 @@
+package appmessage
+
+// MsgUnexpectedPruningPoint represents a kaspa UnexpectedPruningPoint message
+type MsgUnexpectedPruningPoint struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgUnexpectedPruningPoint) Command() MessageCommand {
+	return CmdUnexpectedPruningPoint
+}
+
+// NewMsgUnexpectedPruningPoint returns a new kaspa UnexpectedPruningPoint message
+func NewMsgUnexpectedPruningPoint() *MsgUnexpectedPruningPoint {
+	return &MsgUnexpectedPruningPoint{}
+}

app/appmessage/rpc_ban.go

@@ -0,0 +1,39 @@
+package appmessage
+
+// BanRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type BanRequestMessage struct {
+	baseMessage
+
+	IP string
+}
+
+// Command returns the protocol command string for the message
+func (msg *BanRequestMessage) Command() MessageCommand {
+	return CmdBanRequestMessage
+}
+
+// NewBanRequestMessage returns an instance of the message
+func NewBanRequestMessage(ip string) *BanRequestMessage {
+	return &BanRequestMessage{
+		IP: ip,
+	}
+}
+
+// BanResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type BanResponseMessage struct {
+	baseMessage
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *BanResponseMessage) Command() MessageCommand {
+	return CmdBanResponseMessage
+}
+
+// NewBanResponseMessage returns a instance of the message
+func NewBanResponseMessage() *BanResponseMessage {
+	return &BanResponseMessage{}
+}

app/appmessage/rpc_get_block.go

@@ -5,7 +5,6 @@ package appmessage
 type GetBlockRequestMessage struct {
 	baseMessage
 	Hash                          string
-	SubnetworkID                  string
 	IncludeTransactionVerboseData bool
 }
 
@@ -15,10 +14,9 @@ func (msg *GetBlockRequestMessage) Command() MessageCommand {
 }
 
 // NewGetBlockRequestMessage returns a instance of the message
-func NewGetBlockRequestMessage(hash string, subnetworkID string, includeTransactionVerboseData bool) *GetBlockRequestMessage {
+func NewGetBlockRequestMessage(hash string, includeTransactionVerboseData bool) *GetBlockRequestMessage {
 	return &GetBlockRequestMessage{
 		Hash:                          hash,
-		SubnetworkID:                  subnetworkID,
 		IncludeTransactionVerboseData: includeTransactionVerboseData,
 	}
 }

app/appmessage/rpc_get_blocks.go

@@ -4,9 +4,9 @@ package appmessage
 // its respective RPC message
 type GetBlocksRequestMessage struct {
 	baseMessage
-	LowHash                 string
-	IncludeBlockHexes       bool
-	IncludeBlockVerboseData bool
+	LowHash                       string
+	IncludeBlockVerboseData       bool
+	IncludeTransactionVerboseData bool
 }
 
 // Command returns the protocol command string for the message
@@ -15,11 +15,12 @@ func (msg *GetBlocksRequestMessage) Command() MessageCommand {
 }
 
 // NewGetBlocksRequestMessage returns a instance of the message
-func NewGetBlocksRequestMessage(lowHash string, includeBlockHexes bool, includeBlockVerboseData bool) *GetBlocksRequestMessage {
+func NewGetBlocksRequestMessage(lowHash string, includeBlockVerboseData bool,
+	includeTransactionVerboseData bool) *GetBlocksRequestMessage {
 	return &GetBlocksRequestMessage{
-		LowHash:                 lowHash,
-		IncludeBlockHexes:       includeBlockHexes,
-		IncludeBlockVerboseData: includeBlockVerboseData,
+		LowHash:                       lowHash,
+		IncludeBlockVerboseData:       includeBlockVerboseData,
+		IncludeTransactionVerboseData: includeTransactionVerboseData,
 	}
 }
 
@@ -28,7 +29,6 @@ func NewGetBlocksRequestMessage(lowHash string, includeBlockHexes bool, includeB
 type GetBlocksResponseMessage struct {
 	baseMessage
 	BlockHashes      []string
-	BlockHexes       []string
 	BlockVerboseData []*BlockVerboseData
 
 	Error *RPCError
@@ -45,7 +45,6 @@ func NewGetBlocksResponseMessage(blockHashes []string, blockHexes []string,
 
 	return &GetBlocksResponseMessage{
 		BlockHashes:      blockHashes,
-		BlockHexes:       blockHexes,
 		BlockVerboseData: blockVerboseData,
 	}
 }

app/appmessage/rpc_get_connected_peer_info.go

@@ -46,4 +46,5 @@ type GetConnectedPeerInfoMessage struct {
 	UserAgent                 string
 	AdvertisedProtocolVersion uint32
 	TimeConnected             int64
+	IsIBDPeer                 bool
 }

app/appmessage/rpc_get_info.go

@@ -0,0 +1,38 @@
+package appmessage
+
+// GetInfoRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetInfoRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetInfoRequestMessage) Command() MessageCommand {
+	return CmdGetInfoRequestMessage
+}
+
+// NewGeInfoRequestMessage returns a instance of the message
+func NewGeInfoRequestMessage() *GetInfoRequestMessage {
+	return &GetInfoRequestMessage{}
+}
+
+// GetInfoResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetInfoResponseMessage struct {
+	baseMessage
+	P2PID string
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetInfoResponseMessage) Command() MessageCommand {
+	return CmdGetInfoResponseMessage
+}
+
+// NewGetInfoResponseMessage returns a instance of the message
+func NewGetInfoResponseMessage(p2pID string) *GetInfoResponseMessage {
+	return &GetInfoResponseMessage{
+		P2PID: p2pID,
+	}
+}

app/appmessage/rpc_notify_block_added.go

@@ -37,7 +37,8 @@ func NewNotifyBlockAddedResponseMessage() *NotifyBlockAddedResponseMessage {
 // its respective RPC message
 type BlockAddedNotificationMessage struct {
 	baseMessage
-	Block *MsgBlock
+	Block            *MsgBlock
+	BlockVerboseData *BlockVerboseData
 }
 
 // Command returns the protocol command string for the message
@@ -46,8 +47,9 @@ func (msg *BlockAddedNotificationMessage) Command() MessageCommand {
 }
 
 // NewBlockAddedNotificationMessage returns a instance of the message
-func NewBlockAddedNotificationMessage(block *MsgBlock) *BlockAddedNotificationMessage {
+func NewBlockAddedNotificationMessage(block *MsgBlock, blockVerboseData *BlockVerboseData) *BlockAddedNotificationMessage {
 	return &BlockAddedNotificationMessage{
-		Block: block,
+		Block:            block,
+		BlockVerboseData: blockVerboseData,
 	}
 }

app/appmessage/rpc_stop_notifying_utxos_changed.go

@@ -0,0 +1,37 @@
+package appmessage
+
+// StopNotifyingUTXOsChangedRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type StopNotifyingUTXOsChangedRequestMessage struct {
+	baseMessage
+	Addresses []string
+}
+
+// Command returns the protocol command string for the message
+func (msg *StopNotifyingUTXOsChangedRequestMessage) Command() MessageCommand {
+	return CmdStopNotifyingUTXOsChangedRequestMessage
+}
+
+// NewStopNotifyingUTXOsChangedRequestMessage returns a instance of the message
+func NewStopNotifyingUTXOsChangedRequestMessage(addresses []string) *StopNotifyingUTXOsChangedRequestMessage {
+	return &StopNotifyingUTXOsChangedRequestMessage{
+		Addresses: addresses,
+	}
+}
+
+// StopNotifyingUTXOsChangedResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type StopNotifyingUTXOsChangedResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *StopNotifyingUTXOsChangedResponseMessage) Command() MessageCommand {
+	return CmdStopNotifyingUTXOsChangedResponseMessage
+}
+
+// NewStopNotifyingUTXOsChangedResponseMessage returns a instance of the message
+func NewStopNotifyingUTXOsChangedResponseMessage() *StopNotifyingUTXOsChangedResponseMessage {
+	return &StopNotifyingUTXOsChangedResponseMessage{}
+}

app/appmessage/rpc_submit_block.go

@@ -19,11 +19,33 @@ func NewSubmitBlockRequestMessage(block *MsgBlock) *SubmitBlockRequestMessage {
 	}
 }
 
+// RejectReason describes the reason why a block sent by SubmitBlock was rejected
+type RejectReason byte
+
+// RejectReason constants
+// Not using iota, since in the .proto file those are hardcoded
+const (
+	RejectReasonNone         RejectReason = 0
+	RejectReasonBlockInvalid RejectReason = 1
+	RejectReasonIsInIBD      RejectReason = 2
+)
+
+var rejectReasonToString = map[RejectReason]string{
+	RejectReasonNone:         "None",
+	RejectReasonBlockInvalid: "Block is invalid",
+	RejectReasonIsInIBD:      "Node is in IBD",
+}
+
+func (rr RejectReason) String() string {
+	return rejectReasonToString[rr]
+}
+
 // SubmitBlockResponseMessage is an appmessage corresponding to
 // its respective RPC message
 type SubmitBlockResponseMessage struct {
 	baseMessage
-	Error *RPCError
+	RejectReason RejectReason
+	Error        *RPCError
 }
 
 // Command returns the protocol command string for the message

app/appmessage/rpc_unban.go

@@ -0,0 +1,39 @@
+package appmessage
+
+// UnbanRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type UnbanRequestMessage struct {
+	baseMessage
+
+	IP string
+}
+
+// Command returns the protocol command string for the message
+func (msg *UnbanRequestMessage) Command() MessageCommand {
+	return CmdUnbanRequestMessage
+}
+
+// NewUnbanRequestMessage returns an instance of the message
+func NewUnbanRequestMessage(ip string) *UnbanRequestMessage {
+	return &UnbanRequestMessage{
+		IP: ip,
+	}
+}
+
+// UnbanResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type UnbanResponseMessage struct {
+	baseMessage
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *UnbanResponseMessage) Command() MessageCommand {
+	return CmdUnbanResponseMessage
+}
+
+// NewUnbanResponseMessage returns a instance of the message
+func NewUnbanResponseMessage() *UnbanResponseMessage {
+	return &UnbanResponseMessage{}
+}

app/component_manager.go

@@ -2,9 +2,10 @@ package app
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/domain/utxoindex"
 	"sync/atomic"
 
+	"github.com/kaspanet/kaspad/domain/utxoindex"
+
 	infrastructuredatabase "github.com/kaspanet/kaspad/infrastructure/db/database"
 
 	"github.com/kaspanet/kaspad/domain"
@@ -79,7 +80,7 @@ func (a *ComponentManager) Stop() {
 func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database, interrupt chan<- struct{}) (
 	*ComponentManager, error) {
 
-	domain, err := domain.New(cfg.ActiveNetParams, db)
+	domain, err := domain.New(cfg.ActiveNetParams, db, cfg.IsArchivalNode)
 	if err != nil {
 		return nil, err
 	}
@@ -89,7 +90,7 @@ func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database,
 		return nil, err
 	}
 
-	addressManager, err := addressmanager.New(addressmanager.NewConfig(cfg))
+	addressManager, err := addressmanager.New(addressmanager.NewConfig(cfg), db)
 	if err != nil {
 		return nil, err
 	}

app/protocol/blocklogger/blocklogger.go

@@ -1,58 +0,0 @@
-// Copyright (c) 2015-2017 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package blocklogger
-
-import (
-	"sync"
-	"time"
-
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/util/mstime"
-)
-
-var (
-	receivedLogBlocks int64
-	receivedLogTx     int64
-	lastBlockLogTime  = mstime.Now()
-	mtx               sync.Mutex
-)
-
-// LogBlock logs a new block blue score as an information message
-// to show progress to the user. In order to prevent spam, it limits logging to
-// one message every 10 seconds with duration and totals included.
-func LogBlock(block *externalapi.DomainBlock) {
-	mtx.Lock()
-	defer mtx.Unlock()
-
-	receivedLogBlocks++
-	receivedLogTx += int64(len(block.Transactions))
-
-	now := mstime.Now()
-	duration := now.Sub(lastBlockLogTime)
-	if duration < time.Second*10 {
-		return
-	}
-
-	// Truncate the duration to 10s of milliseconds.
-	tDuration := duration.Round(10 * time.Millisecond)
-
-	// Log information about new block blue score.
-	blockStr := "blocks"
-	if receivedLogBlocks == 1 {
-		blockStr = "block"
-	}
-	txStr := "transactions"
-	if receivedLogTx == 1 {
-		txStr = "transaction"
-	}
-
-	log.Infof("Processed %d %s in the last %s (%d %s, %s)",
-		receivedLogBlocks, blockStr, tDuration, receivedLogTx,
-		txStr, mstime.UnixMilliseconds(block.Header.TimeInMilliseconds()))
-
-	receivedLogBlocks = 0
-	receivedLogTx = 0
-	lastBlockLogTime = now
-}

app/protocol/flowcontext/blocks.go

@@ -1,9 +1,7 @@
 package flowcontext
 
 import (
-	"sync/atomic"
-
-	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/pkg/errors"
 
@@ -39,10 +37,11 @@ func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock,
 	}
 
 	for i, newBlock := range newBlocks {
-		blocklogger.LogBlock(block)
-
 		log.Debugf("OnNewBlock: passing block %s transactions to mining manager", hash)
-		_ = f.Domain().MiningManager().HandleNewBlockTransactions(newBlock.Transactions)
+		_, err = f.Domain().MiningManager().HandleNewBlockTransactions(newBlock.Transactions)
+		if err != nil {
+			return err
+		}
 
 		if f.onBlockAddedToDAGHandler != nil {
 			log.Debugf("OnNewBlock: calling f.onBlockAddedToDAGHandler for block %s", hash)
@@ -115,24 +114,45 @@ func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
 
 // IsIBDRunning returns true if IBD is currently marked as running
 func (f *FlowContext) IsIBDRunning() bool {
-	return atomic.LoadUint32(&f.isInIBD) != 0
+	f.ibdPeerMutex.RLock()
+	defer f.ibdPeerMutex.RUnlock()
+
+	return f.ibdPeer != nil
 }
 
 // TrySetIBDRunning attempts to set `isInIBD`. Returns false
 // if it is already set
-func (f *FlowContext) TrySetIBDRunning() bool {
-	succeeded := atomic.CompareAndSwapUint32(&f.isInIBD, 0, 1)
-	if succeeded {
-		log.Infof("IBD started")
+func (f *FlowContext) TrySetIBDRunning(ibdPeer *peerpkg.Peer) bool {
+	f.ibdPeerMutex.Lock()
+	defer f.ibdPeerMutex.Unlock()
+
+	if f.ibdPeer != nil {
+		return false
 	}
-	return succeeded
+	f.ibdPeer = ibdPeer
+	log.Infof("IBD started")
+
+	return true
 }
 
 // UnsetIBDRunning unsets isInIBD
 func (f *FlowContext) UnsetIBDRunning() {
-	succeeded := atomic.CompareAndSwapUint32(&f.isInIBD, 1, 0)
-	if !succeeded {
+	f.ibdPeerMutex.Lock()
+	defer f.ibdPeerMutex.Unlock()
+
+	if f.ibdPeer == nil {
 		panic("attempted to unset isInIBD when it was not set to begin with")
 	}
+
+	f.ibdPeer = nil
 	log.Infof("IBD finished")
 }
+
+// IBDPeer returns the current IBD peer or null if the node is not
+// in IBD
+func (f *FlowContext) IBDPeer() *peerpkg.Peer {
+	f.ibdPeerMutex.RLock()
+	defer f.ibdPeerMutex.RUnlock()
+
+	return f.ibdPeer
+}

app/protocol/flowcontext/errors.go

@@ -22,7 +22,7 @@ func (*FlowContext) HandleError(err error, flowName string, isStopping *uint32,
 			panic(err)
 		}
 
-		log.Errorf("error from %s: %+v", flowName, err)
+		log.Errorf("error from %s: %s", flowName, err)
 	}
 
 	if atomic.AddUint32(isStopping, 1) == 1 {

app/protocol/flowcontext/flow_context.go

@@ -48,7 +48,8 @@ type FlowContext struct {
 
 	sharedRequestedBlocks *blockrelay.SharedRequestedBlocks
 
-	isInIBD uint32
+	ibdPeer      *peerpkg.Peer
+	ibdPeerMutex sync.RWMutex
 
 	peers      map[id.ID]*peerpkg.Peer
 	peersMutex sync.RWMutex

app/protocol/flowcontext/orphans.go

@@ -4,6 +4,8 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashset"
+	"github.com/kaspanet/kaspad/infrastructure/logger"
 	"github.com/pkg/errors"
 )
 
@@ -160,3 +162,52 @@ func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) (*externa
 	log.Infof("Unorphaned block %s", orphanHash)
 	return blockInsertionResult, true, nil
 }
+
+// GetOrphanRoots returns the roots of the missing ancestors DAG of the given orphan
+func (f *FlowContext) GetOrphanRoots(orphan *externalapi.DomainHash) ([]*externalapi.DomainHash, bool, error) {
+	onEnd := logger.LogAndMeasureExecutionTime(log, "GetOrphanRoots")
+	defer onEnd()
+
+	f.orphansMutex.RLock()
+	defer f.orphansMutex.RUnlock()
+
+	_, ok := f.orphans[*orphan]
+	if !ok {
+		return nil, false, nil
+	}
+
+	queue := []*externalapi.DomainHash{orphan}
+	addedToQueueSet := hashset.New()
+	addedToQueueSet.Add(orphan)
+
+	roots := []*externalapi.DomainHash{}
+	for len(queue) > 0 {
+		var current *externalapi.DomainHash
+		current, queue = queue[0], queue[1:]
+
+		block, ok := f.orphans[*current]
+		if !ok {
+			blockInfo, err := f.domain.Consensus().GetBlockInfo(current)
+			if err != nil {
+				return nil, false, err
+			}
+
+			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
+				roots = append(roots, current)
+			} else {
+				log.Debugf("Block %s was skipped when checking for orphan roots: "+
+					"exists: %t, status: %s", current, blockInfo.Exists, blockInfo.BlockStatus)
+			}
+			continue
+		}
+
+		for _, parent := range block.Header.ParentHashes() {
+			if !addedToQueueSet.Contains(parent) {
+				queue = append(queue, parent)
+				addedToQueueSet.Add(parent)
+			}
+		}
+	}
+
+	return roots, true, nil
+}

app/protocol/flowcontext/should_mine.go

@@ -3,7 +3,7 @@ package flowcontext
 import "github.com/kaspanet/kaspad/util/mstime"
 
 const (
-	maxSelectedParentTimeDiffToAllowMiningInMilliSeconds = 300_000
+	maxSelectedParentTimeDiffToAllowMiningInMilliSeconds = 60 * 60 * 1000 // 1 Hour
 )
 
 // ShouldMine returns whether it's ok to use block template from this node

app/protocol/flows/addressexchange/receiveaddresses.go

@@ -5,14 +5,12 @@ import (
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
 // ReceiveAddressesContext is the interface for the context needed for the ReceiveAddresses flow.
 type ReceiveAddressesContext interface {
-	Config() *config.Config
 	AddressManager() *addressmanager.AddressManager
 }
 
@@ -37,6 +35,5 @@ func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Rou
 		return protocolerrors.Errorf(true, "address count exceeded %d", addressmanager.GetAddressesMax)
 	}
 
-	context.AddressManager().AddAddresses(msgAddresses.AddressList...)
-	return nil
+	return context.AddressManager().AddAddresses(msgAddresses.AddressList...)
 }

app/protocol/flows/addressexchange/sendaddresses.go

@@ -1,7 +1,6 @@
 package addressexchange
 
 import (
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"math/rand"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
@@ -17,16 +16,11 @@ type SendAddressesContext interface {
 // SendAddresses sends addresses to a peer that requests it.
 func SendAddresses(context SendAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
 	for {
-		message, err := incomingRoute.Dequeue()
+		_, err := incomingRoute.Dequeue()
 		if err != nil {
 			return err
 		}
 
-		_, ok := message.(*appmessage.MsgRequestAddresses)
-		if !ok {
-			return protocolerrors.Errorf(true, "unexpected message. "+
-				"Expected: %s, got: %s", appmessage.CmdRequestAddresses, message.Command())
-		}
 		addresses := context.AddressManager().Addresses()
 		msgAddresses := appmessage.NewMsgAddresses(shuffleAddresses(addresses))
 

app/protocol/flows/blockrelay/handle_ibd_block_locator.go

@@ -70,8 +70,14 @@ func HandleIBDBlockLocator(context HandleIBDBlockLocatorContext, incomingRoute *
 		}
 
 		if !foundHighestHashInTheSelectedParentChainOfTargetHash {
-			return protocolerrors.Errorf(true, "no hash was found in the blockLocator "+
+			log.Warnf("no hash was found in the blockLocator "+
 				"that was in the selected parent chain of targetHash %s", targetHash)
+
+			ibdBlockLocatorHighestHashNotFoundMessage := appmessage.NewMsgIBDBlockLocatorHighestHashNotFound()
+			err = outgoingRoute.Enqueue(ibdBlockLocatorHighestHashNotFoundMessage)
+			if err != nil {
+				return err
+			}
 		}
 	}
 }

app/protocol/flows/blockrelay/handle_ibd_block_requests.go

@@ -25,7 +25,8 @@ func HandleIBDBlockRequests(context HandleIBDBlockRequestsContext, incomingRoute
 			return err
 		}
 		msgRequestIBDBlocks := message.(*appmessage.MsgRequestIBDBlocks)
-		for _, hash := range msgRequestIBDBlocks.Hashes {
+		log.Debugf("Got request for %d ibd blocks", len(msgRequestIBDBlocks.Hashes))
+		for i, hash := range msgRequestIBDBlocks.Hashes {
 			// Fetch the block from the database.
 			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
 			if err != nil {
@@ -47,6 +48,7 @@ func HandleIBDBlockRequests(context HandleIBDBlockRequestsContext, incomingRoute
 			if err != nil {
 				return err
 			}
+			log.Debugf("sent %d out of %d", i, len(msgRequestIBDBlocks.Hashes))
 		}
 	}
 }

app/protocol/flows/blockrelay/handle_ibd_root_hash_requests.go

@@ -1,49 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleIBDRootHashRequestsFlowContext is the interface for the context needed for the handleIBDRootHashRequestsFlow flow.
-type HandleIBDRootHashRequestsFlowContext interface {
-	Domain() domain.Domain
-}
-
-type handleIBDRootHashRequestsFlow struct {
-	HandleIBDRootHashRequestsFlowContext
-	incomingRoute, outgoingRoute *router.Route
-}
-
-// HandleIBDRootHashRequests listens to appmessage.MsgRequestIBDRootHashMessage messages and sends
-// the IBD root hash as response.
-func HandleIBDRootHashRequests(context HandleIBDRootHashRequestsFlowContext, incomingRoute,
-	outgoingRoute *router.Route) error {
-	flow := &handleIBDRootHashRequestsFlow{
-		HandleIBDRootHashRequestsFlowContext: context,
-		incomingRoute:                        incomingRoute,
-		outgoingRoute:                        outgoingRoute,
-	}
-
-	return flow.start()
-}
-
-func (flow *handleIBDRootHashRequestsFlow) start() error {
-	for {
-		_, err := flow.incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-
-		pruningPoint, err := flow.Domain().Consensus().PruningPoint()
-		if err != nil {
-			return err
-		}
-
-		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDRootHashMessage(pruningPoint))
-		if err != nil {
-			return err
-		}
-	}
-}

app/protocol/flows/blockrelay/handle_pruning_point_hash_requests.go

@@ -0,0 +1,51 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandlePruningPointHashRequestsFlowContext is the interface for the context needed for the handlePruningPointHashRequestsFlow flow.
+type HandlePruningPointHashRequestsFlowContext interface {
+	Domain() domain.Domain
+}
+
+type handlePruningPointHashRequestsFlow struct {
+	HandlePruningPointHashRequestsFlowContext
+	incomingRoute, outgoingRoute *router.Route
+}
+
+// HandlePruningPointHashRequests listens to appmessage.MsgRequestPruningPointHashMessage messages and sends
+// the pruning point hash as response.
+func HandlePruningPointHashRequests(context HandlePruningPointHashRequestsFlowContext, incomingRoute,
+	outgoingRoute *router.Route) error {
+	flow := &handlePruningPointHashRequestsFlow{
+		HandlePruningPointHashRequestsFlowContext: context,
+		incomingRoute: incomingRoute,
+		outgoingRoute: outgoingRoute,
+	}
+
+	return flow.start()
+}
+
+func (flow *handlePruningPointHashRequestsFlow) start() error {
+	for {
+		_, err := flow.incomingRoute.Dequeue()
+		if err != nil {
+			return err
+		}
+		log.Debugf("Got request for a pruning point hash")
+
+		pruningPoint, err := flow.Domain().Consensus().PruningPoint()
+		if err != nil {
+			return err
+		}
+
+		err = flow.outgoingRoute.Enqueue(appmessage.NewPruningPointHashMessage(pruningPoint))
+		if err != nil {
+			return err
+		}
+		log.Debugf("Sent pruning point hash %s", pruningPoint)
+	}
+}

app/protocol/flows/blockrelay/handle_relay_block_requests.go

@@ -26,6 +26,7 @@ func HandleRelayBlockRequests(context RelayBlockRequestsContext, incomingRoute *
 			return err
 		}
 		getRelayBlocksMessage := message.(*appmessage.MsgRequestRelayBlocks)
+		log.Debugf("Got request for relay blocks with hashes %s", getRelayBlocksMessage.Hashes)
 		for _, hash := range getRelayBlocksMessage.Hashes {
 			// Fetch the block from the database.
 			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
@@ -46,6 +47,7 @@ func HandleRelayBlockRequests(context RelayBlockRequestsContext, incomingRoute *
 			if err != nil {
 				return err
 			}
+			log.Debugf("Relayed block with hash %s", hash)
 		}
 	}
 }

app/protocol/flows/blockrelay/handle_relay_invs.go

@@ -10,7 +10,6 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/pkg/errors"
 )
@@ -24,14 +23,14 @@ var orphanResolutionRange uint32 = 5
 type RelayInvsContext interface {
 	Domain() domain.Domain
 	Config() *config.Config
-	NetAdapter() *netadapter.NetAdapter
 	OnNewBlock(block *externalapi.DomainBlock, blockInsertionResult *externalapi.BlockInsertionResult) error
 	SharedRequestedBlocks() *SharedRequestedBlocks
 	Broadcast(message appmessage.Message) error
 	AddOrphan(orphanBlock *externalapi.DomainBlock)
+	GetOrphanRoots(orphanHash *externalapi.DomainHash) ([]*externalapi.DomainHash, bool, error)
 	IsOrphan(blockHash *externalapi.DomainHash) bool
 	IsIBDRunning() bool
-	TrySetIBDRunning() bool
+	TrySetIBDRunning(ibdPeer *peerpkg.Peer) bool
 	UnsetIBDRunning()
 }
 
@@ -71,7 +70,7 @@ func (flow *handleRelayInvsFlow) start() error {
 		if err != nil {
 			return err
 		}
-		if blockInfo.Exists {
+		if blockInfo.Exists && blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
 			if blockInfo.BlockStatus == externalapi.StatusInvalid {
 				return protocolerrors.Errorf(true, "sent inv of an invalid block %s",
 					inv.Hash)
@@ -81,7 +80,11 @@ func (flow *handleRelayInvsFlow) start() error {
 		}
 
 		if flow.IsOrphan(inv.Hash) {
-			log.Debugf("Block %s is a known orphan. continuing...", inv.Hash)
+			log.Debugf("Block %s is a known orphan. Requesting its missing ancestors", inv.Hash)
+			err := flow.AddOrphanRootsToQueue(inv.Hash)
+			if err != nil {
+				return err
+			}
 			continue
 		}
 
@@ -104,10 +107,19 @@ func (flow *handleRelayInvsFlow) start() error {
 		log.Debugf("Processing block %s", inv.Hash)
 		missingParents, blockInsertionResult, err := flow.processBlock(block)
 		if err != nil {
+			if errors.Is(err, ruleerrors.ErrPrunedBlock) {
+				log.Infof("Ignoring pruned block %s", inv.Hash)
+				continue
+			}
+
+			if errors.Is(err, ruleerrors.ErrDuplicateBlock) {
+				log.Infof("Ignoring duplicate block %s", inv.Hash)
+				continue
+			}
 			return err
 		}
 		if len(missingParents) > 0 {
-			log.Debugf("Block %s contains orphans: %s", inv.Hash, missingParents)
+			log.Debugf("Block %s is orphan and has missing parents: %s", inv.Hash, missingParents)
 			err := flow.processOrphan(block, missingParents)
 			if err != nil {
 				return err
@@ -238,9 +250,10 @@ func (flow *handleRelayInvsFlow) processOrphan(block *externalapi.DomainBlock, m
 	}
 	if isBlockInOrphanResolutionRange {
 		log.Debugf("Block %s is within orphan resolution range. "+
-			"Adding it to the orphan set and requesting its missing parents", blockHash)
-		flow.addToOrphanSetAndRequestMissingParents(block, missingParents)
-		return nil
+			"Adding it to the orphan set", blockHash)
+		flow.AddOrphan(block)
+		log.Debugf("Requesting block %s missing ancestors", blockHash)
+		return flow.AddOrphanRootsToQueue(blockHash)
 	}
 
 	// Start IBD unless we already are in IBD
@@ -277,13 +290,25 @@ func (flow *handleRelayInvsFlow) isBlockInOrphanResolutionRange(blockHash *exter
 	return false, nil
 }
 
-func (flow *handleRelayInvsFlow) addToOrphanSetAndRequestMissingParents(
-	block *externalapi.DomainBlock, missingParents []*externalapi.DomainHash) {
-
-	flow.AddOrphan(block)
-	invMessages := make([]*appmessage.MsgInvRelayBlock, len(missingParents))
-	for i, missingParent := range missingParents {
-		invMessages[i] = appmessage.NewMsgInvBlock(missingParent)
+func (flow *handleRelayInvsFlow) AddOrphanRootsToQueue(orphan *externalapi.DomainHash) error {
+	orphanRoots, orphanExists, err := flow.GetOrphanRoots(orphan)
+	if err != nil {
+		return err
 	}
+
+	if !orphanExists {
+		log.Infof("Orphan block %s was missing from the orphan pool while requesting for its roots. This "+
+			"probably happened because it was randomly evicted immediately after it was added.", orphan)
+	}
+
+	log.Infof("Block %s has %d missing ancestors. Adding them to the invs queue...", orphan, len(orphanRoots))
+
+	invMessages := make([]*appmessage.MsgInvRelayBlock, len(orphanRoots))
+	for i, root := range orphanRoots {
+		log.Debugf("Adding block %s missing ancestor %s to the invs queue", orphan, root)
+		invMessages[i] = appmessage.NewMsgInvBlock(root)
+	}
+
 	flow.invsQueue = append(invMessages, flow.invsQueue...)
+	return nil
 }

app/protocol/flows/blockrelay/handle_request_block_locator.go

@@ -36,6 +36,8 @@ func (flow *handleRequestBlockLocatorFlow) start() error {
 		if err != nil {
 			return err
 		}
+		log.Debugf("Received getBlockLocator with lowHash: %s, highHash: %s, limit: %d",
+			lowHash, highHash, limit)
 
 		locator, err := flow.Domain().Consensus().CreateBlockLocator(lowHash, highHash, limit)
 		if err != nil || len(locator) == 0 {

app/protocol/flows/blockrelay/handle_request_headers.go

@@ -42,9 +42,10 @@ func (flow *handleRequestBlocksFlow) start() error {
 		if err != nil {
 			return err
 		}
+		log.Debugf("Recieved requestHeaders with lowHash: %s, highHash: %s", lowHash, highHash)
 
 		for !lowHash.Equal(highHash) {
-			log.Debugf("Getting block hashes between %s and %s to %s", lowHash, highHash, flow.peer)
+			log.Debugf("Getting block headers between %s and %s to %s", lowHash, highHash, flow.peer)
 
 			// GetHashesBetween is a relatively heavy operation so we limit it
 			// in order to avoid locking the consensus for too long

app/protocol/flows/blockrelay/handle_request_ibd_root_utxo_set_and_block.go

@@ -1,65 +0,0 @@
-package blockrelay
-
-import (
-	"errors"
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleRequestIBDRootUTXOSetAndBlockContext is the interface for the context needed for the HandleRequestIBDRootUTXOSetAndBlock flow.
-type HandleRequestIBDRootUTXOSetAndBlockContext interface {
-	Domain() domain.Domain
-}
-
-type handleRequestIBDRootUTXOSetAndBlockFlow struct {
-	HandleRequestIBDRootUTXOSetAndBlockContext
-	incomingRoute, outgoingRoute *router.Route
-}
-
-// HandleRequestIBDRootUTXOSetAndBlock listens to appmessage.MsgRequestIBDRootUTXOSetAndBlock messages and sends
-// the IBD root UTXO set and block body.
-func HandleRequestIBDRootUTXOSetAndBlock(context HandleRequestIBDRootUTXOSetAndBlockContext, incomingRoute,
-	outgoingRoute *router.Route) error {
-	flow := &handleRequestIBDRootUTXOSetAndBlockFlow{
-		HandleRequestIBDRootUTXOSetAndBlockContext: context,
-		incomingRoute: incomingRoute,
-		outgoingRoute: outgoingRoute,
-	}
-
-	return flow.start()
-}
-
-func (flow *handleRequestIBDRootUTXOSetAndBlockFlow) start() error {
-	for {
-		message, err := flow.incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-		msgRequestIBDRootUTXOSetAndBlock := message.(*appmessage.MsgRequestIBDRootUTXOSetAndBlock)
-
-		utxoSet, err := flow.Domain().Consensus().GetPruningPointUTXOSet(msgRequestIBDRootUTXOSetAndBlock.IBDRoot)
-		if err != nil {
-			if errors.Is(err, ruleerrors.ErrWrongPruningPointHash) {
-				err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDRootNotFound())
-				if err != nil {
-					return err
-				}
-
-				continue
-			}
-		}
-
-		block, err := flow.Domain().Consensus().GetBlock(msgRequestIBDRootUTXOSetAndBlock.IBDRoot)
-		if err != nil {
-			return err
-		}
-
-		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDRootUTXOSetAndBlock(utxoSet,
-			appmessage.DomainBlockToMsgBlock(block)))
-		if err != nil {
-			return err
-		}
-	}
-}

app/protocol/flows/blockrelay/handle_request_pruning_point_utxo_set_and_block.go

@@ -0,0 +1,144 @@
+package blockrelay
+
+import (
+	"errors"
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleRequestPruningPointUTXOSetAndBlockContext is the interface for the context needed for the HandleRequestPruningPointUTXOSetAndBlock flow.
+type HandleRequestPruningPointUTXOSetAndBlockContext interface {
+	Domain() domain.Domain
+}
+
+type handleRequestPruningPointUTXOSetAndBlockFlow struct {
+	HandleRequestPruningPointUTXOSetAndBlockContext
+	incomingRoute, outgoingRoute *router.Route
+}
+
+// HandleRequestPruningPointUTXOSetAndBlock listens to appmessage.MsgRequestPruningPointUTXOSetAndBlock messages and sends
+// the pruning point UTXO set and block body.
+func HandleRequestPruningPointUTXOSetAndBlock(context HandleRequestPruningPointUTXOSetAndBlockContext, incomingRoute,
+	outgoingRoute *router.Route) error {
+	flow := &handleRequestPruningPointUTXOSetAndBlockFlow{
+		HandleRequestPruningPointUTXOSetAndBlockContext: context,
+		incomingRoute: incomingRoute,
+		outgoingRoute: outgoingRoute,
+	}
+
+	return flow.start()
+}
+
+func (flow *handleRequestPruningPointUTXOSetAndBlockFlow) start() error {
+	for {
+		msgRequestPruningPointUTXOSetAndBlock, err := flow.waitForRequestPruningPointUTXOSetAndBlockMessages()
+		if err != nil {
+			return err
+		}
+
+		err = flow.handleRequestPruningPointUTXOSetAndBlockMessage(msgRequestPruningPointUTXOSetAndBlock)
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (flow *handleRequestPruningPointUTXOSetAndBlockFlow) handleRequestPruningPointUTXOSetAndBlockMessage(
+	msgRequestPruningPointUTXOSetAndBlock *appmessage.MsgRequestPruningPointUTXOSetAndBlock) error {
+
+	onEnd := logger.LogAndMeasureExecutionTime(log, "handleRequestPruningPointUTXOSetAndBlockFlow")
+	defer onEnd()
+
+	log.Debugf("Got request for PruningPointHash UTXOSet and Block")
+
+	err := flow.sendPruningPointBlock(msgRequestPruningPointUTXOSetAndBlock)
+	if err != nil {
+		return err
+	}
+
+	return flow.sendPruningPointUTXOSet(msgRequestPruningPointUTXOSetAndBlock)
+}
+
+func (flow *handleRequestPruningPointUTXOSetAndBlockFlow) waitForRequestPruningPointUTXOSetAndBlockMessages() (
+	*appmessage.MsgRequestPruningPointUTXOSetAndBlock, error) {
+
+	message, err := flow.incomingRoute.Dequeue()
+	if err != nil {
+		return nil, err
+	}
+	msgRequestPruningPointUTXOSetAndBlock, ok := message.(*appmessage.MsgRequestPruningPointUTXOSetAndBlock)
+	if !ok {
+		return nil, protocolerrors.Errorf(true, "received unexpected message type. "+
+			"expected: %s, got: %s", appmessage.CmdRequestPruningPointUTXOSetAndBlock, message.Command())
+	}
+	return msgRequestPruningPointUTXOSetAndBlock, nil
+}
+
+func (flow *handleRequestPruningPointUTXOSetAndBlockFlow) sendPruningPointBlock(
+	msgRequestPruningPointUTXOSetAndBlock *appmessage.MsgRequestPruningPointUTXOSetAndBlock) error {
+
+	block, err := flow.Domain().Consensus().GetBlock(msgRequestPruningPointUTXOSetAndBlock.PruningPointHash)
+	if err != nil {
+		return err
+	}
+	log.Debugf("Retrieved pruning block %s", msgRequestPruningPointUTXOSetAndBlock.PruningPointHash)
+
+	return flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDBlock(appmessage.DomainBlockToMsgBlock(block)))
+}
+
+func (flow *handleRequestPruningPointUTXOSetAndBlockFlow) sendPruningPointUTXOSet(
+	msgRequestPruningPointUTXOSetAndBlock *appmessage.MsgRequestPruningPointUTXOSetAndBlock) error {
+
+	// Send the UTXO set in `step`-sized chunks
+	const step = 1000
+	var fromOutpoint *externalapi.DomainOutpoint
+	chunksSent := 0
+	for {
+		pruningPointUTXOs, err := flow.Domain().Consensus().GetPruningPointUTXOs(
+			msgRequestPruningPointUTXOSetAndBlock.PruningPointHash, fromOutpoint, step)
+		if err != nil {
+			if errors.Is(err, ruleerrors.ErrWrongPruningPointHash) {
+				return flow.outgoingRoute.Enqueue(appmessage.NewMsgUnexpectedPruningPoint())
+			}
+		}
+
+		log.Debugf("Retrieved %d UTXOs for pruning block %s",
+			len(pruningPointUTXOs), msgRequestPruningPointUTXOSetAndBlock.PruningPointHash)
+
+		outpointAndUTXOEntryPairs :=
+			appmessage.DomainOutpointAndUTXOEntryPairsToOutpointAndUTXOEntryPairs(pruningPointUTXOs)
+		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgPruningPointUTXOSetChunk(outpointAndUTXOEntryPairs))
+		if err != nil {
+			return err
+		}
+
+		if len(pruningPointUTXOs) < step {
+			log.Debugf("Finished sending UTXOs for pruning block %s",
+				msgRequestPruningPointUTXOSetAndBlock.PruningPointHash)
+
+			return flow.outgoingRoute.Enqueue(appmessage.NewMsgDonePruningPointUTXOSetChunks())
+		}
+
+		fromOutpoint = pruningPointUTXOs[len(pruningPointUTXOs)-1].Outpoint
+		chunksSent++
+
+		// Wait for the peer to request more chunks every `ibdBatchSize` chunks
+		if chunksSent%ibdBatchSize == 0 {
+			message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+			if err != nil {
+				return err
+			}
+			_, ok := message.(*appmessage.MsgRequestNextPruningPointUTXOSetChunk)
+			if !ok {
+				return protocolerrors.Errorf(true, "received unexpected message type. "+
+					"expected: %s, got: %s", appmessage.CmdRequestNextPruningPointUTXOSetChunk, message.Command())
+			}
+		}
+	}
+}

app/protocol/flows/blockrelay/hashes_queue_set.go

@@ -1,37 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-type hashesQueueSet struct {
-	queue []*externalapi.DomainHash
-	set   map[externalapi.DomainHash]struct{}
-}
-
-func (r *hashesQueueSet) enqueueIfNotExists(hash *externalapi.DomainHash) {
-	if _, ok := r.set[*hash]; ok {
-		return
-	}
-	r.queue = append(r.queue, hash)
-	r.set[*hash] = struct{}{}
-}
-
-func (r *hashesQueueSet) dequeue(numItems int) []*externalapi.DomainHash {
-	var hashes []*externalapi.DomainHash
-	hashes, r.queue = r.queue[:numItems], r.queue[numItems:]
-	for _, hash := range hashes {
-		delete(r.set, *hash)
-	}
-	return hashes
-}
-
-func (r *hashesQueueSet) len() int {
-	return len(r.queue)
-}
-
-func newHashesQueueSet() *hashesQueueSet {
-	return &hashesQueueSet{
-		set: make(map[externalapi.DomainHash]struct{}),
-	}
-}

app/protocol/flows/blockrelay/ibd.go

@@ -1,8 +1,13 @@
 package blockrelay
 
 import (
+	"fmt"
 	"time"
 
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model"
+
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
@@ -13,7 +18,7 @@ import (
 )
 
 func (flow *handleRelayInvsFlow) runIBDIfNotRunning(highHash *externalapi.DomainHash) error {
-	wasIBDNotRunning := flow.TrySetIBDRunning()
+	wasIBDNotRunning := flow.TrySetIBDRunning(flow.peer)
 	if !wasIBDNotRunning {
 		log.Debugf("IBD is already running")
 		return nil
@@ -22,67 +27,28 @@ func (flow *handleRelayInvsFlow) runIBDIfNotRunning(highHash *externalapi.Domain
 
 	log.Debugf("IBD started with peer %s and highHash %s", flow.peer, highHash)
 
-	// Fetch all the headers if we don't already have them
-	log.Debugf("Downloading headers up to %s", highHash)
-	err := flow.syncHeaders(highHash)
+	log.Debugf("Syncing headers up to %s", highHash)
+	headersSynced, err := flow.syncHeaders(highHash)
 	if err != nil {
 		return err
 	}
-	log.Debugf("Finished downloading headers up to %s", highHash)
+	if !headersSynced {
+		log.Debugf("Aborting IBD because the headers failed to sync")
+		return nil
+	}
+	log.Debugf("Finished syncing headers up to %s", highHash)
 
-	// Fetch the UTXO set if we don't already have it
-	log.Debugf("Checking if there's a new pruning point under %s", highHash)
-	err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDRootHashMessage())
+	log.Debugf("Syncing the current pruning point UTXO set")
+	syncedPruningPointUTXOSetSuccessfully, err := flow.syncPruningPointUTXOSet()
 	if err != nil {
 		return err
 	}
-
-	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
-	if err != nil {
-		return err
+	if !syncedPruningPointUTXOSetSuccessfully {
+		log.Debugf("Aborting IBD because the pruning point UTXO set failed to sync")
+		return nil
 	}
+	log.Debugf("Finished syncing the current pruning point UTXO set")
 
-	msgIBDRootHash, ok := message.(*appmessage.MsgIBDRootHashMessage)
-	if !ok {
-		return protocolerrors.Errorf(true, "received unexpected message type. "+
-			"expected: %s, got: %s", appmessage.CmdIBDRootHash, message.Command())
-	}
-
-	blockInfo, err := flow.Domain().Consensus().GetBlockInfo(msgIBDRootHash.Hash)
-	if err != nil {
-		return err
-	}
-
-	if blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
-		log.Infof("Checking if the suggested pruning point %s is compatible to the node DAG", msgIBDRootHash.Hash)
-		isValid, err := flow.Domain().Consensus().IsValidPruningPoint(msgIBDRootHash.Hash)
-		if err != nil {
-			return err
-		}
-
-		if !isValid {
-			log.Infof("The suggested pruning point %s is incompatible to this node DAG, so stopping IBD with this"+
-				" peer", msgIBDRootHash.Hash)
-			return nil
-		}
-
-		log.Info("Fetching the pruning point UTXO set")
-		succeed, err := flow.fetchMissingUTXOSet(msgIBDRootHash.Hash)
-		if err != nil {
-			return err
-		}
-
-		if !succeed {
-			log.Infof("Couldn't successfully fetch the pruning point UTXO set. Stopping IBD.")
-			return nil
-		}
-
-		log.Info("Fetched the new pruning point UTXO set")
-	} else {
-		log.Debugf("Already has the block data of the new suggested pruning point %s", msgIBDRootHash.Hash)
-	}
-
-	// Fetch the block bodies
 	log.Debugf("Downloading block bodies up to %s", highHash)
 	err = flow.syncMissingBlockBodies(highHash)
 	if err != nil {
@@ -93,87 +59,153 @@ func (flow *handleRelayInvsFlow) runIBDIfNotRunning(highHash *externalapi.Domain
 	return nil
 }
 
-func (flow *handleRelayInvsFlow) syncHeaders(highHash *externalapi.DomainHash) error {
-	highHashReceived := false
-	for !highHashReceived {
-		log.Debugf("Trying to find highest shared chain block with peer %s with high hash %s", flow.peer, highHash)
-		highestSharedBlockHash, err := flow.findHighestSharedBlockHash(highHash)
-		if err != nil {
-			return err
-		}
-		log.Debugf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
-
-		err = flow.downloadHeaders(highestSharedBlockHash, highHash)
-		if err != nil {
-			return err
-		}
-
-		// We're finished once highHash has been inserted into the DAG
-		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(highHash)
-		if err != nil {
-			return err
-		}
-		highHashReceived = blockInfo.Exists
-		log.Debugf("Headers downloaded from peer %s. Are further headers required: %t", flow.peer, !highHashReceived)
+// syncHeaders attempts to sync headers from the peer. This method may fail
+// because the peer and us have conflicting pruning points. In that case we
+// return (false, nil) so that we may stop IBD gracefully.
+func (flow *handleRelayInvsFlow) syncHeaders(highHash *externalapi.DomainHash) (bool, error) {
+	log.Debugf("Trying to find highest shared chain block with peer %s with high hash %s", flow.peer, highHash)
+	highestSharedBlockHash, highestSharedBlockFound, err := flow.findHighestSharedBlockHash(highHash)
+	if err != nil {
+		return false, err
 	}
-	return nil
+	if !highestSharedBlockFound {
+		return false, nil
+	}
+	log.Debugf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
+
+	err = flow.downloadHeaders(highestSharedBlockHash, highHash)
+	if err != nil {
+		return false, err
+	}
+
+	// If the highHash has not been received, the peer is misbehaving
+	highHashBlockInfo, err := flow.Domain().Consensus().GetBlockInfo(highHash)
+	if err != nil {
+		return false, err
+	}
+	if !highHashBlockInfo.Exists {
+		return false, protocolerrors.Errorf(true, "did not receive "+
+			"highHash header %s from peer %s during header download", highHash, flow.peer)
+	}
+	log.Debugf("Headers downloaded from peer %s", flow.peer)
+	return true, nil
 }
 
-func (flow *handleRelayInvsFlow) findHighestSharedBlockHash(targetHash *externalapi.DomainHash) (*externalapi.DomainHash, error) {
-	lowHash := flow.Config().ActiveNetParams.GenesisHash
-	highHash, err := flow.Domain().Consensus().GetHeadersSelectedTip()
+// findHighestSharedBlock attempts to find the highest shared block between the peer
+// and this node. This method may fail because the peer and us have conflicting pruning
+// points. In that case we return (nil, false, nil) so that we may stop IBD gracefully.
+func (flow *handleRelayInvsFlow) findHighestSharedBlockHash(
+	targetHash *externalapi.DomainHash) (*externalapi.DomainHash, bool, error) {
+
+	log.Debugf("Sending a blockLocator to %s between pruning point and headers selected tip", flow.peer)
+	blockLocator, err := flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 
-	for !lowHash.Equal(highHash) {
-		log.Debugf("Sending a blockLocator to %s between %s and %s", flow.peer, lowHash, highHash)
-		blockLocator, err := flow.Domain().Consensus().CreateBlockLocator(lowHash, highHash, 0)
+	for {
+		highestHash, highestHashFound, err := flow.fetchHighestHash(targetHash, blockLocator)
 		if err != nil {
-			return nil, err
+			return nil, false, err
+		}
+		if !highestHashFound {
+			return nil, false, nil
+		}
+		highestHashIndex, err := flow.findHighestHashIndex(highestHash, blockLocator)
+		if err != nil {
+			return nil, false, err
 		}
 
-		ibdBlockLocatorMessage := appmessage.NewMsgIBDBlockLocator(targetHash, blockLocator)
-		err = flow.outgoingRoute.Enqueue(ibdBlockLocatorMessage)
-		if err != nil {
-			return nil, err
-		}
-		message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
-		if err != nil {
-			return nil, err
-		}
-		ibdBlockLocatorHighestHashMessage, ok := message.(*appmessage.MsgIBDBlockLocatorHighestHash)
-		if !ok {
-			return nil, protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s, got: %s", appmessage.CmdIBDBlockLocatorHighestHash, message.Command())
-		}
-		highestHash := ibdBlockLocatorHighestHashMessage.HighestHash
-		log.Debugf("The highest hash the peer %s knows is %s", flow.peer, highestHash)
+		if highestHashIndex == 0 ||
+			// If the block locator contains only two adjacent chain blocks, the
+			// syncer will always find the same highest chain block, so to avoid
+			// an endless loop, we explicitly stop the loop in such situation.
+			(len(blockLocator) == 2 && highestHashIndex == 1) {
 
-		highestHashIndex := 0
-		highestHashIndexFound := false
-		for i, blockLocatorHash := range blockLocator {
-			if highestHash.Equal(blockLocatorHash) {
-				highestHashIndex = i
-				highestHashIndexFound = true
-				break
-			}
+			return highestHash, true, nil
 		}
-		if !highestHashIndexFound {
-			return nil, protocolerrors.Errorf(true, "highest hash %s "+
-				"returned from peer %s is not in the original blockLocator", highestHash, flow.peer)
-		}
-		log.Debugf("The index of the highest hash in the original "+
-			"blockLocator sent to %s is %d", flow.peer, highestHashIndex)
 
 		locatorHashAboveHighestHash := highestHash
 		if highestHashIndex > 0 {
 			locatorHashAboveHighestHash = blockLocator[highestHashIndex-1]
 		}
-		highHash = locatorHashAboveHighestHash
-		lowHash = highestHash
+
+		blockLocator, err = flow.nextBlockLocator(highestHash, locatorHashAboveHighestHash)
+		if err != nil {
+			return nil, false, err
+		}
+	}
+}
+
+func (flow *handleRelayInvsFlow) nextBlockLocator(lowHash, highHash *externalapi.DomainHash) (externalapi.BlockLocator, error) {
+	log.Debugf("Sending a blockLocator to %s between %s and %s", flow.peer, lowHash, highHash)
+	blockLocator, err := flow.Domain().Consensus().CreateHeadersSelectedChainBlockLocator(lowHash, highHash)
+	if err != nil {
+		if errors.Is(model.ErrBlockNotInSelectedParentChain, err) {
+			return nil, err
+		}
+		log.Debugf("Headers selected parent chain moved since findHighestSharedBlockHash - " +
+			"restarting with full block locator")
+		blockLocator, err = flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return blockLocator, nil
+}
+
+func (flow *handleRelayInvsFlow) findHighestHashIndex(
+	highestHash *externalapi.DomainHash, blockLocator externalapi.BlockLocator) (int, error) {
+
+	highestHashIndex := 0
+	highestHashIndexFound := false
+	for i, blockLocatorHash := range blockLocator {
+		if highestHash.Equal(blockLocatorHash) {
+			highestHashIndex = i
+			highestHashIndexFound = true
+			break
+		}
+	}
+	if !highestHashIndexFound {
+		return 0, protocolerrors.Errorf(true, "highest hash %s "+
+			"returned from peer %s is not in the original blockLocator", highestHash, flow.peer)
+	}
+	log.Debugf("The index of the highest hash in the original "+
+		"blockLocator sent to %s is %d", flow.peer, highestHashIndex)
+
+	return highestHashIndex, nil
+}
+
+// fetchHighestHash attempts to fetch the highest hash the peer knows amongst the given
+// blockLocator. This method may fail because the peer and us have conflicting pruning
+// points. In that case we return (nil, false, nil) so that we may stop IBD gracefully.
+func (flow *handleRelayInvsFlow) fetchHighestHash(
+	targetHash *externalapi.DomainHash, blockLocator externalapi.BlockLocator) (*externalapi.DomainHash, bool, error) {
+
+	ibdBlockLocatorMessage := appmessage.NewMsgIBDBlockLocator(targetHash, blockLocator)
+	err := flow.outgoingRoute.Enqueue(ibdBlockLocatorMessage)
+	if err != nil {
+		return nil, false, err
+	}
+	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
+	if err != nil {
+		return nil, false, err
+	}
+	switch message := message.(type) {
+	case *appmessage.MsgIBDBlockLocatorHighestHash:
+		highestHash := message.HighestHash
+		log.Debugf("The highest hash the peer %s knows is %s", flow.peer, highestHash)
+
+		return highestHash, true, nil
+	case *appmessage.MsgIBDBlockLocatorHighestHashNotFound:
+		log.Debugf("Peer %s does not know any block within our blockLocator. "+
+			"This should only happen if there's a DAG split deeper than the pruning point.", flow.peer)
+		return nil, false, nil
+	default:
+		return nil, false, protocolerrors.Errorf(true, "received unexpected message type. "+
+			"expected: %s, got: %s", appmessage.CmdIBDBlockLocatorHighestHash, message.Command())
 	}
-	return highHash, nil
 }
 
 func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externalapi.DomainHash,
@@ -189,7 +221,6 @@ func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externa
 	// headers
 	blockHeadersMessageChan := make(chan *appmessage.BlockHeadersMessage, 2)
 	errChan := make(chan error)
-	doneChan := make(chan interface{})
 	spawn("handleRelayInvsFlow-downloadHeaders", func() {
 		for {
 			blockHeadersMessage, doneIBD, err := flow.receiveHeaders()
@@ -198,7 +229,7 @@ func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externa
 				return
 			}
 			if doneIBD {
-				doneChan <- struct{}{}
+				close(blockHeadersMessageChan)
 				return
 			}
 
@@ -214,7 +245,10 @@ func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externa
 
 	for {
 		select {
-		case blockHeadersMessage := <-blockHeadersMessageChan:
+		case blockHeadersMessage, ok := <-blockHeadersMessageChan:
+			if !ok {
+				return nil
+			}
 			for _, header := range blockHeadersMessage.BlockHeaders {
 				err = flow.processHeader(header)
 				if err != nil {
@@ -223,8 +257,6 @@ func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externa
 			}
 		case err := <-errChan:
 			return err
-		case <-doneChan:
-			return nil
 		}
 	}
 }
@@ -274,59 +306,186 @@ func (flow *handleRelayInvsFlow) processHeader(msgBlockHeader *appmessage.MsgBlo
 		if !errors.As(err, &ruleerrors.RuleError{}) {
 			return errors.Wrapf(err, "failed to process header %s during IBD", blockHash)
 		}
-		log.Infof("Rejected block header %s from %s during IBD: %s", blockHash, flow.peer, err)
 
-		return protocolerrors.Wrapf(true, err, "got invalid block %s during IBD", blockHash)
+		if errors.Is(err, ruleerrors.ErrDuplicateBlock) {
+			log.Debugf("Skipping block header %s as it is a duplicate", blockHash)
+		} else {
+			log.Infof("Rejected block header %s from %s during IBD: %s", blockHash, flow.peer, err)
+			return protocolerrors.Wrapf(true, err, "got invalid block header %s during IBD", blockHash)
+		}
 	}
 
 	return nil
 }
 
-func (flow *handleRelayInvsFlow) fetchMissingUTXOSet(ibdRootHash *externalapi.DomainHash) (succeed bool, err error) {
-	err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDRootUTXOSetAndBlock(ibdRootHash))
+func (flow *handleRelayInvsFlow) syncPruningPointUTXOSet() (bool, error) {
+	log.Debugf("Checking if a new pruning point is available")
+	err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestPruningPointHashMessage())
+	if err != nil {
+		return false, err
+	}
+	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
+	if err != nil {
+		return false, err
+	}
+	msgPruningPointHash, ok := message.(*appmessage.MsgPruningPointHashMessage)
+	if !ok {
+		return false, protocolerrors.Errorf(true, "received unexpected message type. "+
+			"expected: %s, got: %s", appmessage.CmdPruningPointHash, message.Command())
+	}
+
+	blockInfo, err := flow.Domain().Consensus().GetBlockInfo(msgPruningPointHash.Hash)
 	if err != nil {
 		return false, err
 	}
 
-	utxoSet, block, found, err := flow.receiveIBDRootUTXOSetAndBlock()
+	if !blockInfo.Exists {
+		return false, errors.Errorf("The pruning point header is missing")
+	}
+
+	if blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
+		log.Debugf("Already has the block data of the new suggested pruning point %s", msgPruningPointHash.Hash)
+		return true, nil
+	}
+
+	log.Infof("Checking if the suggested pruning point %s is compatible to the node DAG", msgPruningPointHash.Hash)
+	isValid, err := flow.Domain().Consensus().IsValidPruningPoint(msgPruningPointHash.Hash)
 	if err != nil {
 		return false, err
 	}
 
-	if !found {
+	if !isValid {
+		log.Infof("The suggested pruning point %s is incompatible to this node DAG, so stopping IBD with this"+
+			" peer", msgPruningPointHash.Hash)
 		return false, nil
 	}
 
-	err = flow.Domain().Consensus().ValidateAndInsertPruningPoint(block, utxoSet)
+	log.Info("Fetching the pruning point UTXO set")
+	succeed, err := flow.fetchMissingUTXOSet(msgPruningPointHash.Hash)
+	if err != nil {
+		return false, err
+	}
+
+	if !succeed {
+		log.Infof("Couldn't successfully fetch the pruning point UTXO set. Stopping IBD.")
+		return false, nil
+	}
+
+	log.Info("Fetched the new pruning point UTXO set")
+	return true, nil
+}
+
+func (flow *handleRelayInvsFlow) fetchMissingUTXOSet(pruningPointHash *externalapi.DomainHash) (succeed bool, err error) {
+	defer func() {
+		err := flow.Domain().Consensus().ClearImportedPruningPointData()
+		if err != nil {
+			panic(fmt.Sprintf("failed to clear imported pruning point data: %s", err))
+		}
+	}()
+
+	err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestPruningPointUTXOSetAndBlock(pruningPointHash))
+	if err != nil {
+		return false, err
+	}
+
+	block, err := flow.receivePruningPointBlock()
+	if err != nil {
+		return false, err
+	}
+
+	receivedAll, err := flow.receiveAndInsertPruningPointUTXOSet(pruningPointHash)
+	if err != nil {
+		return false, err
+	}
+	if !receivedAll {
+		return false, nil
+	}
+
+	err = flow.Domain().Consensus().ValidateAndInsertImportedPruningPoint(block)
 	if err != nil {
 		// TODO: Find a better way to deal with finality conflicts.
 		if errors.Is(err, ruleerrors.ErrSuggestedPruningViolatesFinality) {
 			return false, nil
 		}
-		return false, protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "error with IBD root UTXO set")
+		return false, protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "error with pruning point UTXO set")
 	}
 
 	return true, nil
 }
 
-func (flow *handleRelayInvsFlow) receiveIBDRootUTXOSetAndBlock() ([]byte, *externalapi.DomainBlock, bool, error) {
+func (flow *handleRelayInvsFlow) receivePruningPointBlock() (*externalapi.DomainBlock, error) {
+	onEnd := logger.LogAndMeasureExecutionTime(log, "receivePruningPointBlock")
+	defer onEnd()
+
 	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
 	if err != nil {
-		return nil, nil, false, err
+		return nil, err
 	}
 
-	switch message := message.(type) {
-	case *appmessage.MsgIBDRootUTXOSetAndBlock:
-		return message.UTXOSet,
-			appmessage.MsgBlockToDomainBlock(message.Block), true, nil
-	case *appmessage.MsgIBDRootNotFound:
-		return nil, nil, false, nil
-	default:
-		return nil, nil, false,
-			protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s or %s, got: %s",
-				appmessage.CmdIBDRootUTXOSetAndBlock, appmessage.CmdIBDRootNotFound, message.Command(),
+	ibdBlockMessage, ok := message.(*appmessage.MsgIBDBlock)
+	if !ok {
+		return nil, protocolerrors.Errorf(true, "received unexpected message type. "+
+			"expected: %s, got: %s", appmessage.CmdIBDBlock, message.Command())
+	}
+	block := appmessage.MsgBlockToDomainBlock(ibdBlockMessage.MsgBlock)
+
+	log.Debugf("Received pruning point block %s", consensushashing.BlockHash(block))
+
+	return block, nil
+}
+
+func (flow *handleRelayInvsFlow) receiveAndInsertPruningPointUTXOSet(
+	pruningPointHash *externalapi.DomainHash) (bool, error) {
+
+	onEnd := logger.LogAndMeasureExecutionTime(log, "receiveAndInsertPruningPointUTXOSet")
+	defer onEnd()
+
+	receivedChunkCount := 0
+	receivedUTXOCount := 0
+	for {
+		message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
+		if err != nil {
+			return false, err
+		}
+
+		switch message := message.(type) {
+		case *appmessage.MsgPruningPointUTXOSetChunk:
+			receivedUTXOCount += len(message.OutpointAndUTXOEntryPairs)
+			domainOutpointAndUTXOEntryPairs :=
+				appmessage.OutpointAndUTXOEntryPairsToDomainOutpointAndUTXOEntryPairs(message.OutpointAndUTXOEntryPairs)
+
+			err := flow.Domain().Consensus().AppendImportedPruningPointUTXOs(domainOutpointAndUTXOEntryPairs)
+			if err != nil {
+				return false, err
+			}
+
+			receivedChunkCount++
+			if receivedChunkCount%ibdBatchSize == 0 {
+				log.Debugf("Received %d UTXO set chunks so far, totaling in %d UTXOs",
+					receivedChunkCount, receivedUTXOCount)
+
+				requestNextPruningPointUTXOSetChunkMessage := appmessage.NewMsgRequestNextPruningPointUTXOSetChunk()
+				err := flow.outgoingRoute.Enqueue(requestNextPruningPointUTXOSetChunkMessage)
+				if err != nil {
+					return false, err
+				}
+			}
+
+		case *appmessage.MsgDonePruningPointUTXOSetChunks:
+			log.Infof("Finished receiving the UTXO set. Total UTXOs: %d", receivedUTXOCount)
+			return true, nil
+
+		case *appmessage.MsgUnexpectedPruningPoint:
+			log.Infof("Could not receive the next UTXO chunk because the pruning point %s "+
+				"is no longer the pruning point of peer %s", pruningPointHash, flow.peer)
+			return false, nil
+
+		default:
+			return false, protocolerrors.Errorf(true, "received unexpected message type. "+
+				"expected: %s or %s or %s, got: %s", appmessage.CmdPruningPointUTXOSetChunk,
+				appmessage.CmdDonePruningPointUTXOSetChunks, appmessage.CmdUnexpectedPruningPoint, message.Command(),
 			)
+		}
 	}
 }
 
@@ -335,6 +494,13 @@ func (flow *handleRelayInvsFlow) syncMissingBlockBodies(highHash *externalapi.Do
 	if err != nil {
 		return err
 	}
+	if len(hashes) == 0 {
+		// Blocks can be inserted inside the DAG during IBD if those were requested before IBD started.
+		// In rare cases, all the IBD blocks might be already inserted by the time we reach this point.
+		// In these cases - GetMissingBlockBodyHashes would return an empty array.
+		log.Debugf("No missing block body hashes found.")
+		return nil
+	}
 
 	for offset := 0; offset < len(hashes); offset += ibdBatchSize {
 		var hashesToRequest []*externalapi.DomainHash
@@ -369,6 +535,10 @@ func (flow *handleRelayInvsFlow) syncMissingBlockBodies(highHash *externalapi.Do
 
 			blockInsertionResult, err := flow.Domain().Consensus().ValidateAndInsertBlock(block)
 			if err != nil {
+				if errors.Is(err, ruleerrors.ErrDuplicateBlock) {
+					log.Debugf("Skipping IBD Block %s as it has already been added to the DAG", blockHash)
+					continue
+				}
 				return protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "invalid block %s", blockHash)
 			}
 			err = flow.OnNewBlock(block, blockInsertionResult)

app/protocol/flows/blockrelay/send_virtual_selected_parent_inv.go

@@ -0,0 +1,28 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// SendVirtualSelectedParentInvContext is the interface for the context needed for the SendVirtualSelectedParentInv flow.
+type SendVirtualSelectedParentInvContext interface {
+	Domain() domain.Domain
+}
+
+// SendVirtualSelectedParentInv sends a peer the selected parent hash of the virtual
+func SendVirtualSelectedParentInv(context SendVirtualSelectedParentInvContext,
+	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
+
+	virtualSelectedParent, err := context.Domain().Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return err
+	}
+
+	log.Debugf("Sending virtual selected parent hash %s to peer %s", virtualSelectedParent, peer)
+
+	virtualSelectedParentInv := appmessage.NewMsgInvBlock(virtualSelectedParent)
+	return outgoingRoute.Enqueue(virtualSelectedParentInv)
+}

app/protocol/flows/handshake/handshake.go

@@ -82,14 +82,17 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 
 	err := context.AddToPeers(peer)
 	if err != nil {
-		if errors.As(err, &common.ErrPeerWithSameIDExists) {
+		if errors.Is(err, common.ErrPeerWithSameIDExists) {
 			return nil, protocolerrors.Wrap(false, err, "peer already exists")
 		}
 		return nil, err
 	}
 
 	if peerAddress != nil {
-		context.AddressManager().AddAddresses(peerAddress)
+		err := context.AddressManager().AddAddresses(peerAddress)
+		if err != nil {
+			return nil, err
+		}
 	}
 	return peer, nil
 }

app/protocol/flows/handshake/receiveversion.go

@@ -42,9 +42,11 @@ func ReceiveVersion(context HandleHandshakeContext, incomingRoute *router.Route,
 }
 
 func (flow *receiveVersionFlow) start() (*appmessage.NetAddress, error) {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "receiveVersionFlow.start()")
+	onEnd := logger.LogAndMeasureExecutionTime(log, "receiveVersionFlow.start")
 	defer onEnd()
 
+	log.Debugf("Starting receiveVersionFlow with %s", flow.peer.Address())
+
 	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
 	if err != nil {
 		return nil, err
@@ -58,7 +60,7 @@ func (flow *receiveVersionFlow) start() (*appmessage.NetAddress, error) {
 	}
 
 	if !allowSelfConnections && flow.NetAdapter().ID().IsEqual(msgVersion.ID) {
-		return nil, protocolerrors.New(true, "connected to self")
+		return nil, protocolerrors.New(false, "connected to self")
 	}
 
 	// Disconnect and ban peers from a different network

app/protocol/flows/handshake/sendversion.go

@@ -51,6 +51,8 @@ func (flow *sendVersionFlow) start() error {
 	onEnd := logger.LogAndMeasureExecutionTime(log, "sendVersionFlow.start")
 	defer onEnd()
 
+	log.Debugf("Starting sendVersionFlow with %s", flow.peer.Address())
+
 	// Version message.
 	localAddress := flow.AddressManager().BestLocalAddress(flow.peer.Connection().NetAddress())
 	subnetworkID := flow.Config().SubnetworkID

app/protocol/flows/testing/common_test.go

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

app/protocol/flows/testing/receiveaddresses_test.go

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

app/protocol/flows/testing/testing.go

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

app/protocol/flows/transactionrelay/handle_relayed_transactions.go

@@ -159,7 +159,7 @@ func (flow *handleRelayedTransactionsFlow) receiveTransactions(requestedTransact
 			return err
 		}
 		if msgTxNotFound != nil {
-			if msgTxNotFound.ID != expectedID {
+			if !msgTxNotFound.ID.Equal(expectedID) {
 				return protocolerrors.Errorf(true, "expected transaction %s, but got %s",
 					expectedID, msgTxNotFound.ID)
 			}

app/protocol/manager.go

@@ -37,6 +37,12 @@ func (m *Manager) Peers() []*peerpkg.Peer {
 	return m.context.Peers()
 }
 
+// IBDPeer returns the current IBD peer or null if the node is not
+// in IBD
+func (m *Manager) IBDPeer() *peerpkg.Peer {
+	return m.context.IBDPeer()
+}
+
 // AddTransaction adds transaction to the mempool and propagates it.
 func (m *Manager) AddTransaction(tx *externalapi.DomainTransaction) error {
 	return m.context.AddTransaction(tx)
@@ -73,3 +79,8 @@ func (m *Manager) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMemp
 func (m *Manager) ShouldMine() (bool, error) {
 	return m.context.ShouldMine()
 }
+
+// IsIBDRunning returns true if IBD is currently marked as running
+func (m *Manager) IsIBDRunning() bool {
+	return m.context.IsIBDRunning()
+}

app/protocol/protocol.go

@@ -2,6 +2,7 @@ package protocol
 
 import (
 	"github.com/kaspanet/kaspad/app/protocol/flows/rejects"
+	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
 	"sync/atomic"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
@@ -44,6 +45,7 @@ func (m *Manager) routerInitializer(router *routerpkg.Router, netConnection *net
 			panic(err)
 		}
 		if isBanned {
+			log.Infof("Peer %s is banned. Disconnecting...", netConnection)
 			netConnection.Disconnect()
 			return
 		}
@@ -78,7 +80,7 @@ func (m *Manager) handleError(err error, netConnection *netadapter.NetConnection
 			log.Warnf("Banning %s (reason: %s)", netConnection, protocolErr.Cause)
 
 			err := m.context.ConnectionManager().Ban(netConnection)
-			if err != nil && !errors.Is(err, addressmanager.ErrAddressNotFound) {
+			if !errors.Is(err, connmanager.ErrCannotBanPermanent) {
 				panic(err)
 			}
 
@@ -87,6 +89,7 @@ func (m *Manager) handleError(err error, netConnection *netadapter.NetConnection
 				panic(err)
 			}
 		}
+		log.Debugf("Disconnecting from %s (reason: %s)", netConnection, protocolErr.Cause)
 		netConnection.Disconnect()
 		return
 	}
@@ -133,10 +136,16 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 	outgoingRoute := router.OutgoingRoute()
 
 	return []*flow{
+		m.registerOneTimeFlow("SendVirtualSelectedParentInv", router, []appmessage.MessageCommand{},
+			isStopping, errChan, func(route *routerpkg.Route, peer *peerpkg.Peer) error {
+				return blockrelay.SendVirtualSelectedParentInv(m.context, outgoingRoute, peer)
+			}),
+
 		m.registerFlow("HandleRelayInvs", router, []appmessage.MessageCommand{
 			appmessage.CmdInvRelayBlock, appmessage.CmdBlock, appmessage.CmdBlockLocator, appmessage.CmdIBDBlock,
-			appmessage.CmdDoneHeaders, appmessage.CmdIBDRootNotFound, appmessage.CmdIBDRootUTXOSetAndBlock,
-			appmessage.CmdBlockHeaders, appmessage.CmdIBDRootHash, appmessage.CmdIBDBlockLocatorHighestHash},
+			appmessage.CmdDoneHeaders, appmessage.CmdUnexpectedPruningPoint, appmessage.CmdPruningPointUTXOSetChunk,
+			appmessage.CmdBlockHeaders, appmessage.CmdPruningPointHash, appmessage.CmdIBDBlockLocatorHighestHash,
+			appmessage.CmdIBDBlockLocatorHighestHashNotFound, appmessage.CmdDonePruningPointUTXOSetChunks},
 			isStopping, errChan, func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
 				return blockrelay.HandleRelayInvs(m.context, incomingRoute,
 					outgoingRoute, peer)
@@ -163,10 +172,11 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 			},
 		),
 
-		m.registerFlow("HandleRequestIBDRootUTXOSetAndBlock", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestIBDRootUTXOSetAndBlock}, isStopping, errChan,
+		m.registerFlow("HandleRequestPruningPointUTXOSetAndBlock", router,
+			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointUTXOSetAndBlock,
+				appmessage.CmdRequestNextPruningPointUTXOSetChunk}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRequestIBDRootUTXOSetAndBlock(m.context, incomingRoute, outgoingRoute)
+				return blockrelay.HandleRequestPruningPointUTXOSetAndBlock(m.context, incomingRoute, outgoingRoute)
 			},
 		),
 
@@ -177,10 +187,10 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 			},
 		),
 
-		m.registerFlow("HandleIBDRootHashRequests", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestIBDRootHash}, isStopping, errChan,
+		m.registerFlow("HandlePruningPointHashRequests", router,
+			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointHash}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleIBDRootHashRequests(m.context, incomingRoute, outgoingRoute)
+				return blockrelay.HandlePruningPointHashRequests(m.context, incomingRoute, outgoingRoute)
 			},
 		),
 

app/rpc/manager.go

@@ -69,7 +69,12 @@ func (m *Manager) NotifyBlockAddedToDAG(block *externalapi.DomainBlock, blockIns
 		return err
 	}
 
-	blockAddedNotification := appmessage.NewBlockAddedNotificationMessage(appmessage.DomainBlockToMsgBlock(block))
+	msgBlock := appmessage.DomainBlockToMsgBlock(block)
+	blockVerboseData, err := m.context.BuildBlockVerboseData(block.Header, block, false)
+	if err != nil {
+		return err
+	}
+	blockAddedNotification := appmessage.NewBlockAddedNotificationMessage(msgBlock, blockVerboseData)
 	return m.context.NotificationManager.NotifyBlockAdded(blockAddedNotification)
 }
 

app/rpc/rpc.go

@@ -35,9 +35,13 @@ var handlers = map[appmessage.MessageCommand]handler{
 	appmessage.CmdShutDownRequestMessage:                                    rpchandlers.HandleShutDown,
 	appmessage.CmdGetHeadersRequestMessage:                                  rpchandlers.HandleGetHeaders,
 	appmessage.CmdNotifyUTXOsChangedRequestMessage:                          rpchandlers.HandleNotifyUTXOsChanged,
+	appmessage.CmdStopNotifyingUTXOsChangedRequestMessage:                   rpchandlers.HandleStopNotifyingUTXOsChanged,
 	appmessage.CmdGetUTXOsByAddressesRequestMessage:                         rpchandlers.HandleGetUTXOsByAddresses,
 	appmessage.CmdGetVirtualSelectedParentBlueScoreRequestMessage:           rpchandlers.HandleGetVirtualSelectedParentBlueScore,
 	appmessage.CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage: rpchandlers.HandleNotifyVirtualSelectedParentBlueScoreChanged,
+	appmessage.CmdBanRequestMessage:                                         rpchandlers.HandleBan,
+	appmessage.CmdUnbanRequestMessage:                                       rpchandlers.HandleUnban,
+	appmessage.CmdGetInfoRequestMessage:                                     rpchandlers.HandleGetInfo,
 }
 
 func (m *Manager) routerInitializer(router *router.Router, netConnection *netadapter.NetConnection) {

app/rpc/rpccontext/chain_changed.go

@@ -9,7 +9,7 @@ import (
 // ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage converts
 // VirtualSelectedParentChainChanges to VirtualSelectedParentChainChangedNotificationMessage
 func (ctx *Context) ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
-	selectedParentChainChanges *externalapi.SelectedParentChainChanges) (*appmessage.VirtualSelectedParentChainChangedNotificationMessage, error) {
+	selectedParentChainChanges *externalapi.SelectedChainPath) (*appmessage.VirtualSelectedParentChainChangedNotificationMessage, error) {
 
 	removedChainBlockHashes := make([]string, len(selectedParentChainChanges.Removed))
 	for i, removed := range selectedParentChainChanges.Removed {

app/rpc/rpccontext/notificationmanager.go

@@ -31,7 +31,7 @@ type NotificationListener struct {
 	propagateUTXOsChangedNotifications                          bool
 	propagateVirtualSelectedParentBlueScoreChangedNotifications bool
 
-	propagateUTXOsChangedNotificationAddresses []*UTXOsChangedNotificationAddress
+	propagateUTXOsChangedNotificationAddresses map[utxoindex.ScriptPublicKeyString]*UTXOsChangedNotificationAddress
 }
 
 // NewNotificationManager creates a new NotificationManager
@@ -216,33 +216,70 @@ func (nl *NotificationListener) PropagateFinalityConflictResolvedNotifications()
 }
 
 // PropagateUTXOsChangedNotifications instructs the listener to send UTXOs changed notifications
-// to the remote listener
+// to the remote listener for the given addresses. Subsequent calls instruct the listener to
+// send UTXOs changed notifications for those addresses along with the old ones. Duplicate addresses
+// are ignored.
 func (nl *NotificationListener) PropagateUTXOsChangedNotifications(addresses []*UTXOsChangedNotificationAddress) {
-	nl.propagateUTXOsChangedNotifications = true
-	nl.propagateUTXOsChangedNotificationAddresses = addresses
+	if !nl.propagateUTXOsChangedNotifications {
+		nl.propagateUTXOsChangedNotifications = true
+		nl.propagateUTXOsChangedNotificationAddresses =
+			make(map[utxoindex.ScriptPublicKeyString]*UTXOsChangedNotificationAddress, len(addresses))
+	}
+
+	for _, address := range addresses {
+		nl.propagateUTXOsChangedNotificationAddresses[address.ScriptPublicKeyString] = address
+	}
+}
+
+// StopPropagatingUTXOsChangedNotifications instructs the listener to stop sending UTXOs
+// changed notifications to the remote listener for the given addresses. Addresses for which
+// notifications are not currently sent are ignored.
+func (nl *NotificationListener) StopPropagatingUTXOsChangedNotifications(addresses []*UTXOsChangedNotificationAddress) {
+	if !nl.propagateUTXOsChangedNotifications {
+		return
+	}
+
+	for _, address := range addresses {
+		delete(nl.propagateUTXOsChangedNotificationAddresses, address.ScriptPublicKeyString)
+	}
 }
 
 func (nl *NotificationListener) convertUTXOChangesToUTXOsChangedNotification(
 	utxoChanges *utxoindex.UTXOChanges) *appmessage.UTXOsChangedNotificationMessage {
 
+	// As an optimization, we iterate over the smaller set (O(n)) among the two below
+	// and check existence over the larger set (O(1))
+	utxoChangesSize := len(utxoChanges.Added) + len(utxoChanges.Removed)
+	addressesSize := len(nl.propagateUTXOsChangedNotificationAddresses)
+
 	notification := &appmessage.UTXOsChangedNotificationMessage{}
-	for _, listenerAddress := range nl.propagateUTXOsChangedNotificationAddresses {
-		listenerScriptPublicKeyString := listenerAddress.ScriptPublicKeyString
-		if addedPairs, ok := utxoChanges.Added[listenerScriptPublicKeyString]; ok {
-			notification.Added = ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(listenerAddress.Address, addedPairs)
+	if utxoChangesSize < addressesSize {
+		for scriptPublicKeyString, addedPairs := range utxoChanges.Added {
+			if listenerAddress, ok := nl.propagateUTXOsChangedNotificationAddresses[scriptPublicKeyString]; ok {
+				utxosByAddressesEntries := ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(listenerAddress.Address, addedPairs)
+				notification.Added = append(notification.Added, utxosByAddressesEntries...)
+			}
 		}
-		if removedOutpoints, ok := utxoChanges.Removed[listenerScriptPublicKeyString]; ok {
-			for outpoint := range removedOutpoints {
-				notification.Removed = append(notification.Removed, &appmessage.UTXOsByAddressesEntry{
-					Address: listenerAddress.Address,
-					Outpoint: &appmessage.RPCOutpoint{
-						TransactionID: outpoint.TransactionID.String(),
-						Index:         outpoint.Index,
-					},
-				})
+		for scriptPublicKeyString, removedOutpoints := range utxoChanges.Removed {
+			if listenerAddress, ok := nl.propagateUTXOsChangedNotificationAddresses[scriptPublicKeyString]; ok {
+				utxosByAddressesEntries := convertUTXOOutpointsToUTXOsByAddressesEntries(listenerAddress.Address, removedOutpoints)
+				notification.Removed = append(notification.Removed, utxosByAddressesEntries...)
+			}
+		}
+	} else {
+		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)
+				notification.Removed = append(notification.Removed, utxosByAddressesEntries...)
 			}
 		}
 	}
+
 	return notification
 }
 

app/rpc/rpccontext/utxos_by_addresses.go

@@ -2,6 +2,9 @@ package rpccontext
 
 import (
 	"encoding/hex"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/pkg/errors"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/domain/utxoindex"
@@ -28,3 +31,43 @@ func ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(address string, pair
 	}
 	return utxosByAddressesEntries
 }
+
+// convertUTXOOutpointsToUTXOsByAddressesEntries converts
+// UTXOOutpoints to a slice of UTXOsByAddressesEntry
+func convertUTXOOutpointsToUTXOsByAddressesEntries(address string, outpoints utxoindex.UTXOOutpoints) []*appmessage.UTXOsByAddressesEntry {
+	utxosByAddressesEntries := make([]*appmessage.UTXOsByAddressesEntry, 0, len(outpoints))
+	for outpoint := range outpoints {
+		utxosByAddressesEntries = append(utxosByAddressesEntries, &appmessage.UTXOsByAddressesEntry{
+			Address: address,
+			Outpoint: &appmessage.RPCOutpoint{
+				TransactionID: outpoint.TransactionID.String(),
+				Index:         outpoint.Index,
+			},
+		})
+	}
+	return utxosByAddressesEntries
+}
+
+// ConvertAddressStringsToUTXOsChangedNotificationAddresses converts address strings
+// to UTXOsChangedNotificationAddresses
+func (ctx *Context) ConvertAddressStringsToUTXOsChangedNotificationAddresses(
+	addressStrings []string) ([]*UTXOsChangedNotificationAddress, error) {
+
+	addresses := make([]*UTXOsChangedNotificationAddress, len(addressStrings))
+	for i, addressString := range addressStrings {
+		address, err := util.DecodeAddress(addressString, ctx.Config.ActiveNetParams.Prefix)
+		if err != nil {
+			return nil, errors.Errorf("Could not decode address '%s': %s", addressString, err)
+		}
+		scriptPublicKey, err := txscript.PayToAddrScript(address)
+		if err != nil {
+			return nil, errors.Errorf("Could not create a scriptPublicKey for address '%s': %s", addressString, err)
+		}
+		scriptPublicKeyString := utxoindex.ConvertScriptPublicKeyToString(scriptPublicKey)
+		addresses[i] = &UTXOsChangedNotificationAddress{
+			Address:               addressString,
+			ScriptPublicKeyString: scriptPublicKeyString,
+		}
+	}
+	return addresses, nil
+}

app/rpc/rpccontext/verbosedata.go

@@ -4,6 +4,9 @@ import (
 	"encoding/hex"
 	"fmt"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/util/difficulty"
+	"github.com/pkg/errors"
 	"math"
 	"math/big"
 	"strconv"
@@ -19,18 +22,31 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/domain/dagconfig"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/pointers"
 )
 
-// BuildBlockVerboseData builds a BlockVerboseData from the given block.
-func (ctx *Context) BuildBlockVerboseData(blockHeader externalapi.BlockHeader, includeTransactionVerboseData bool) (*appmessage.BlockVerboseData, error) {
+// ErrBuildBlockVerboseDataInvalidBlock indicates that a block that was given to BuildBlockVerboseData is invalid.
+var ErrBuildBlockVerboseDataInvalidBlock = errors.New("ErrBuildBlockVerboseDataInvalidBlock")
+
+// BuildBlockVerboseData builds a BlockVerboseData from the given blockHeader.
+// A block may optionally also be given if it's available in the calling context.
+func (ctx *Context) BuildBlockVerboseData(blockHeader externalapi.BlockHeader, block *externalapi.DomainBlock,
+	includeTransactionVerboseData bool) (*appmessage.BlockVerboseData, error) {
+
+	onEnd := logger.LogAndMeasureExecutionTime(log, "BuildBlockVerboseData")
+	defer onEnd()
+
 	hash := consensushashing.HeaderHash(blockHeader)
 
 	blockInfo, err := ctx.Domain.Consensus().GetBlockInfo(hash)
 	if err != nil {
 		return nil, err
 	}
+
+	if blockInfo.BlockStatus == externalapi.StatusInvalid {
+		return nil, errors.Wrap(ErrBuildBlockVerboseDataInvalidBlock, "cannot build verbose data for "+
+			"invalid block")
+	}
+
 	result := &appmessage.BlockVerboseData{
 		Hash:                 hash.String(),
 		Version:              blockHeader.Version(),
@@ -48,9 +64,11 @@ func (ctx *Context) BuildBlockVerboseData(blockHeader externalapi.BlockHeader, i
 	}
 
 	if blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
-		block, err := ctx.Domain.Consensus().GetBlock(hash)
-		if err != nil {
-			return nil, err
+		if block == nil {
+			block, err = ctx.Domain.Consensus().GetBlock(hash)
+			if err != nil {
+				return nil, err
+			}
 		}
 
 		txIDs := make([]string, len(block.Transactions))
@@ -83,7 +101,7 @@ func (ctx *Context) GetDifficultyRatio(bits uint32, params *dagconfig.Params) fl
 	// converted back to a number. Note this is not the same as the proof of
 	// work limit directly because the block difficulty is encoded in a block
 	// with the compact form which loses precision.
-	target := util.CompactToBig(bits)
+	target := difficulty.CompactToBig(bits)
 
 	difficulty := new(big.Rat).SetFrac(params.PowMax, target)
 	diff, _ := difficulty.Float64()
@@ -100,6 +118,9 @@ func (ctx *Context) BuildTransactionVerboseData(tx *externalapi.DomainTransactio
 	blockHeader externalapi.BlockHeader, blockHash string) (
 	*appmessage.TransactionVerboseData, error) {
 
+	onEnd := logger.LogAndMeasureExecutionTime(log, "BuildTransactionVerboseData")
+	defer onEnd()
+
 	var payloadHash string
 	if tx.SubnetworkID != subnetworks.SubnetworkIDNative {
 		payloadHash = tx.PayloadHash.String()
@@ -167,7 +188,7 @@ func (ctx *Context) buildTransactionVerboseOutputs(tx *externalapi.DomainTransac
 		passesFilter := len(filterAddrMap) == 0
 		var encodedAddr string
 		if addr != nil {
-			encodedAddr = *pointers.String(addr.EncodeAddress())
+			encodedAddr = addr.EncodeAddress()
 
 			// If the filter doesn't already pass, make it pass if
 			// the address exists in the filter.

app/rpc/rpchandlers/ban.go

@@ -0,0 +1,28 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"net"
+)
+
+// HandleBan handles the respectively named RPC command
+func HandleBan(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	banRequest := request.(*appmessage.BanRequestMessage)
+	ip := net.ParseIP(banRequest.IP)
+	if ip == nil {
+		errorMessage := &appmessage.BanResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Could not parse IP %s", banRequest.IP)
+		return errorMessage, nil
+	}
+
+	err := context.ConnectionManager.BanByIP(ip)
+	if err != nil {
+		errorMessage := &appmessage.BanResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Could not ban IP: %s", err)
+		return errorMessage, nil
+	}
+	response := appmessage.NewBanResponseMessage()
+	return response, nil
+}

app/rpc/rpchandlers/get_block.go

@@ -5,6 +5,7 @@ import (
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/pkg/errors"
 )
 
 // HandleGetBlock handles the respectively named RPC command
@@ -28,10 +29,16 @@ func HandleGetBlock(context *rpccontext.Context, _ *router.Router, request appme
 
 	response := appmessage.NewGetBlockResponseMessage()
 
-	blockVerboseData, err := context.BuildBlockVerboseData(header, getBlockRequest.IncludeTransactionVerboseData)
+	blockVerboseData, err := context.BuildBlockVerboseData(header, nil, getBlockRequest.IncludeTransactionVerboseData)
 	if err != nil {
+		if errors.Is(err, rpccontext.ErrBuildBlockVerboseDataInvalidBlock) {
+			errorMessage := &appmessage.GetBlockResponseMessage{}
+			errorMessage.Error = appmessage.RPCErrorf("Block %s is invalid", hash)
+			return errorMessage, nil
+		}
 		return nil, err
 	}
+
 	response.BlockVerboseData = blockVerboseData
 
 	return response, nil

app/rpc/rpchandlers/get_blocks.go

@@ -3,6 +3,8 @@ 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/hashes"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
@@ -14,7 +16,80 @@ const (
 
 // HandleGetBlocks handles the respectively named RPC command
 func HandleGetBlocks(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	response := &appmessage.GetBlocksResponseMessage{}
-	response.Error = appmessage.RPCErrorf("not implemented")
+	getBlocksRequest := request.(*appmessage.GetBlocksRequestMessage)
+
+	// Validate that user didn't set IncludeTransactionVerboseData without setting IncludeBlockVerboseData
+	if !getBlocksRequest.IncludeBlockVerboseData && getBlocksRequest.IncludeTransactionVerboseData {
+		return &appmessage.GetBlocksResponseMessage{
+			Error: appmessage.RPCErrorf(
+				"If includeTransactionVerboseData is set, then includeBlockVerboseData must be set as well"),
+		}, nil
+	}
+
+	// Decode lowHash
+	// If lowHash is empty - use genesis instead.
+	lowHash := context.Config.ActiveNetParams.GenesisHash
+	if getBlocksRequest.LowHash != "" {
+		var err error
+		lowHash, err = externalapi.NewDomainHashFromString(getBlocksRequest.LowHash)
+		if err != nil {
+			return &appmessage.GetBlocksResponseMessage{
+				Error: appmessage.RPCErrorf("Could not decode lowHash %s: %s", getBlocksRequest.LowHash, err),
+			}, nil
+		}
+	}
+
+	// Get hashes between lowHash and virtualSelectedParent
+	virtualSelectedParent, err := context.Domain.Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return nil, err
+	}
+	blockHashes, err := context.Domain.Consensus().GetHashesBetween(
+		lowHash, virtualSelectedParent, maxBlocksInGetBlocksResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	// prepend low hash to make it inclusive
+	blockHashes = append([]*externalapi.DomainHash{lowHash}, blockHashes...)
+
+	// If there are no maxBlocksInGetBlocksResponse between lowHash and virtualSelectedParent -
+	// add virtualSelectedParent's anticone
+	if len(blockHashes) < maxBlocksInGetBlocksResponse {
+		virtualSelectedParentAnticone, err := context.Domain.Consensus().Anticone(virtualSelectedParent)
+		if err != nil {
+			return nil, err
+		}
+		blockHashes = append(blockHashes, virtualSelectedParentAnticone...)
+	}
+
+	// Both GetHashesBetween and Anticone might return more then the allowed number of blocks, so
+	// trim any extra blocks.
+	if len(blockHashes) > maxBlocksInGetBlocksResponse {
+		blockHashes = blockHashes[:maxBlocksInGetBlocksResponse]
+	}
+
+	// Prepare the response
+	response := &appmessage.GetBlocksResponseMessage{
+		BlockHashes: hashes.ToStrings(blockHashes),
+	}
+
+	// Retrieve all block data in case BlockVerboseData was requested
+	if getBlocksRequest.IncludeBlockVerboseData {
+		response.BlockVerboseData = make([]*appmessage.BlockVerboseData, len(blockHashes))
+		for i, blockHash := range blockHashes {
+			blockHeader, err := context.Domain.Consensus().GetBlockHeader(blockHash)
+			if err != nil {
+				return nil, err
+			}
+			blockVerboseData, err := context.BuildBlockVerboseData(blockHeader, nil,
+				getBlocksRequest.IncludeTransactionVerboseData)
+			if err != nil {
+				return nil, err
+			}
+
+			response.BlockVerboseData[i] = blockVerboseData
+		}
+	}
 	return response, nil
 }

app/rpc/rpchandlers/get_blocks_test.go

@@ -0,0 +1,144 @@
+package rpchandlers_test
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/app/rpc/rpchandlers"
+	"github.com/kaspanet/kaspad/domain/consensus"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/model/testapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
+	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/domain/miningmanager"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+)
+
+type fakeDomain struct {
+	testapi.TestConsensus
+}
+
+func (d fakeDomain) Consensus() externalapi.Consensus           { return d }
+func (d fakeDomain) MiningManager() miningmanager.MiningManager { return nil }
+
+func TestHandleGetBlocks(t *testing.T) {
+	testutils.ForAllNets(t, true, func(t *testing.T, params *dagconfig.Params) {
+		factory := consensus.NewFactory()
+		tc, teardown, err := factory.NewTestConsensus(params, false, "TestHandleGetBlocks")
+		if err != nil {
+			t.Fatalf("Error setting up consensus: %+v", err)
+		}
+		defer teardown(false)
+
+		fakeContext := rpccontext.Context{
+			Config: &config.Config{Flags: &config.Flags{NetworkFlags: config.NetworkFlags{ActiveNetParams: params}}},
+			Domain: fakeDomain{tc},
+		}
+
+		getBlocks := func(lowHash *externalapi.DomainHash) *appmessage.GetBlocksResponseMessage {
+			request := appmessage.GetBlocksRequestMessage{}
+			if lowHash != nil {
+				request.LowHash = lowHash.String()
+			}
+			response, err := rpchandlers.HandleGetBlocks(&fakeContext, nil, &request)
+			if err != nil {
+				t.Fatalf("Expected empty request to not fail, instead: '%v'", err)
+			}
+			return response.(*appmessage.GetBlocksResponseMessage)
+		}
+
+		filterAntiPast := func(povBlock *externalapi.DomainHash, slice []*externalapi.DomainHash) []*externalapi.DomainHash {
+			antipast := make([]*externalapi.DomainHash, 0, len(slice))
+
+			for _, blockHash := range slice {
+				isInPastOfPovBlock, err := tc.DAGTopologyManager().IsAncestorOf(blockHash, povBlock)
+				if err != nil {
+					t.Fatalf("Failed doing reachability check: '%v'", err)
+				}
+				if !isInPastOfPovBlock {
+					antipast = append(antipast, blockHash)
+				}
+			}
+			return antipast
+		}
+
+		// Create a DAG with the following structure:
+		//          merging block
+		//         /      |      \
+		//      split1  split2   split3
+		//        \       |      /
+		//         merging block
+		//         /      |      \
+		//      split1  split2   split3
+		//        \       |      /
+		//               etc.
+		expectedOrder := make([]*externalapi.DomainHash, 0, 40)
+		mergingBlock := params.GenesisHash
+		for i := 0; i < 10; i++ {
+			splitBlocks := make([]*externalapi.DomainHash, 0, 3)
+			for j := 0; j < 3; j++ {
+				blockHash, _, err := tc.AddBlock([]*externalapi.DomainHash{mergingBlock}, nil, nil)
+				if err != nil {
+					t.Fatalf("Failed adding block: %v", err)
+				}
+				splitBlocks = append(splitBlocks, blockHash)
+			}
+			sort.Sort(sort.Reverse(testutils.NewTestGhostDAGSorter(splitBlocks, tc, t)))
+			restOfSplitBlocks, selectedParent := splitBlocks[:len(splitBlocks)-1], splitBlocks[len(splitBlocks)-1]
+			expectedOrder = append(expectedOrder, selectedParent)
+			expectedOrder = append(expectedOrder, restOfSplitBlocks...)
+
+			mergingBlock, _, err = tc.AddBlock(splitBlocks, nil, nil)
+			if err != nil {
+				t.Fatalf("Failed adding block: %v", err)
+			}
+			expectedOrder = append(expectedOrder, mergingBlock)
+		}
+
+		virtualSelectedParent, err := tc.GetVirtualSelectedParent()
+		if err != nil {
+			t.Fatalf("Failed getting SelectedParent: %v", err)
+		}
+		if !virtualSelectedParent.Equal(expectedOrder[len(expectedOrder)-1]) {
+			t.Fatalf("Expected %s to be selectedParent, instead found: %s", expectedOrder[len(expectedOrder)-1], virtualSelectedParent)
+		}
+
+		requestSelectedParent := getBlocks(virtualSelectedParent)
+		if !reflect.DeepEqual(requestSelectedParent.BlockHashes, hashes.ToStrings([]*externalapi.DomainHash{virtualSelectedParent})) {
+			t.Fatalf("TestHandleGetBlocks expected:\n%v\nactual:\n%v", virtualSelectedParent, requestSelectedParent.BlockHashes)
+		}
+
+		for i, blockHash := range expectedOrder {
+			expectedBlocks := filterAntiPast(blockHash, expectedOrder)
+			expectedBlocks = append([]*externalapi.DomainHash{blockHash}, expectedBlocks...)
+
+			actualBlocks := getBlocks(blockHash)
+			if !reflect.DeepEqual(actualBlocks.BlockHashes, hashes.ToStrings(expectedBlocks)) {
+				t.Fatalf("TestHandleGetBlocks %d \nexpected: \n%v\nactual:\n%v", i,
+					hashes.ToStrings(expectedBlocks), actualBlocks.BlockHashes)
+			}
+		}
+
+		// Make explicitly sure that if lowHash==highHash we get a slice with a single hash.
+		actualBlocks := getBlocks(virtualSelectedParent)
+		if !reflect.DeepEqual(actualBlocks.BlockHashes, []string{virtualSelectedParent.String()}) {
+			t.Fatalf("TestHandleGetBlocks expected blocks to contain just '%s', instead got: \n%v",
+				virtualSelectedParent, actualBlocks.BlockHashes)
+		}
+
+		expectedOrder = append([]*externalapi.DomainHash{params.GenesisHash}, expectedOrder...)
+		actualOrder := getBlocks(nil)
+		if !reflect.DeepEqual(actualOrder.BlockHashes, hashes.ToStrings(expectedOrder)) {
+			t.Fatalf("TestHandleGetBlocks \nexpected: %v \nactual:\n%v", expectedOrder, actualOrder.BlockHashes)
+		}
+
+		requestAllExplictly := getBlocks(params.GenesisHash)
+		if !reflect.DeepEqual(requestAllExplictly.BlockHashes, hashes.ToStrings(expectedOrder)) {
+			t.Fatalf("TestHandleGetBlocks \nexpected: \n%v\n. actual:\n%v", expectedOrder, requestAllExplictly.BlockHashes)
+		}
+	})
+}

app/rpc/rpchandlers/get_connected_peer_info.go

@@ -9,6 +9,7 @@ import (
 // HandleGetConnectedPeerInfo handles the respectively named RPC command
 func HandleGetConnectedPeerInfo(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
 	peers := context.ProtocolManager.Peers()
+	ibdPeer := context.ProtocolManager.IBDPeer()
 	infos := make([]*appmessage.GetConnectedPeerInfoMessage, 0, len(peers))
 	for _, peer := range peers {
 		info := &appmessage.GetConnectedPeerInfoMessage{
@@ -20,6 +21,7 @@ func HandleGetConnectedPeerInfo(context *rpccontext.Context, _ *router.Router, _
 			UserAgent:                 peer.UserAgent(),
 			AdvertisedProtocolVersion: peer.AdvertisedProtocolVersion(),
 			TimeConnected:             peer.TimeConnected().Milliseconds(),
+			IsIBDPeer:                 peer == ibdPeer,
 		}
 		infos = append(infos, info)
 	}

app/rpc/rpchandlers/get_info.go

@@ -0,0 +1,13 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleGetInfo handles the respectively named RPC command
+func HandleGetInfo(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	response := appmessage.NewGetInfoResponseMessage(context.NetAdapter.ID().String())
+	return response, nil
+}

app/rpc/rpchandlers/get_mempool_entries.go

@@ -3,12 +3,27 @@ package rpchandlers
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
 // HandleGetMempoolEntries handles the respectively named RPC command
 func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	response := &appmessage.GetMempoolEntriesResponseMessage{}
-	response.Error = appmessage.RPCErrorf("not implemented")
-	return response, nil
+
+	transactions := context.Domain.MiningManager().AllTransactions()
+	entries := make([]*appmessage.MempoolEntry, 0, len(transactions))
+	for _, tx := range transactions {
+		transactionVerboseData, err := context.BuildTransactionVerboseData(
+			tx, consensushashing.TransactionID(tx).String(), nil, "")
+		if err != nil {
+			return nil, err
+		}
+
+		entries = append(entries, &appmessage.MempoolEntry{
+			Fee:                    tx.Fee,
+			TransactionVerboseData: transactionVerboseData,
+		})
+	}
+
+	return appmessage.NewGetMempoolEntriesResponseMessage(entries), nil
 }

app/rpc/rpchandlers/notify_utxos_changed.go

@@ -3,10 +3,7 @@ package rpchandlers
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
-	"github.com/kaspanet/kaspad/domain/utxoindex"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util"
 )
 
 // HandleNotifyUTXOsChanged handles the respectively named RPC command
@@ -18,26 +15,11 @@ func HandleNotifyUTXOsChanged(context *rpccontext.Context, router *router.Router
 	}
 
 	notifyUTXOsChangedRequest := request.(*appmessage.NotifyUTXOsChangedRequestMessage)
-
-	addresses := make([]*rpccontext.UTXOsChangedNotificationAddress, len(notifyUTXOsChangedRequest.Addresses))
-	for i, addressString := range notifyUTXOsChangedRequest.Addresses {
-		address, err := util.DecodeAddress(addressString, context.Config.ActiveNetParams.Prefix)
-		if err != nil {
-			errorMessage := appmessage.NewNotifyUTXOsChangedResponseMessage()
-			errorMessage.Error = appmessage.RPCErrorf("Could not decode address '%s': %s", addressString, err)
-			return errorMessage, nil
-		}
-		scriptPublicKey, err := txscript.PayToAddrScript(address)
-		if err != nil {
-			errorMessage := appmessage.NewNotifyUTXOsChangedResponseMessage()
-			errorMessage.Error = appmessage.RPCErrorf("Could not create a scriptPublicKey for address '%s': %s", addressString, err)
-			return errorMessage, nil
-		}
-		scriptPublicKeyString := utxoindex.ConvertScriptPublicKeyToString(scriptPublicKey)
-		addresses[i] = &rpccontext.UTXOsChangedNotificationAddress{
-			Address:               addressString,
-			ScriptPublicKeyString: scriptPublicKeyString,
-		}
+	addresses, err := context.ConvertAddressStringsToUTXOsChangedNotificationAddresses(notifyUTXOsChangedRequest.Addresses)
+	if err != nil {
+		errorMessage := appmessage.NewNotifyUTXOsChangedResponseMessage()
+		errorMessage.Error = appmessage.RPCErrorf("Parsing error: %s", err)
+		return errorMessage, nil
 	}
 
 	listener, err := context.NotificationManager.Listener(router)

app/rpc/rpchandlers/stop_notifying_utxos_changed.go

@@ -0,0 +1,33 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleStopNotifyingUTXOsChanged handles the respectively named RPC command
+func HandleStopNotifyingUTXOsChanged(context *rpccontext.Context, router *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	if !context.Config.UTXOIndex {
+		errorMessage := appmessage.NewStopNotifyingUTXOsChangedResponseMessage()
+		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --utxoindex")
+		return errorMessage, nil
+	}
+
+	stopNotifyingUTXOsChangedRequest := request.(*appmessage.StopNotifyingUTXOsChangedRequestMessage)
+	addresses, err := context.ConvertAddressStringsToUTXOsChangedNotificationAddresses(stopNotifyingUTXOsChangedRequest.Addresses)
+	if err != nil {
+		errorMessage := appmessage.NewNotifyUTXOsChangedResponseMessage()
+		errorMessage.Error = appmessage.RPCErrorf("Parsing error: %s", err)
+		return errorMessage, nil
+	}
+
+	listener, err := context.NotificationManager.Listener(router)
+	if err != nil {
+		return nil, err
+	}
+	listener.StopPropagatingUTXOsChangedNotifications(addresses)
+
+	response := appmessage.NewStopNotifyingUTXOsChangedResponseMessage()
+	return response, nil
+}

app/rpc/rpchandlers/submit_block.go

@@ -16,14 +16,22 @@ func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request ap
 	msgBlock := submitBlockRequest.Block
 	domainBlock := appmessage.MsgBlockToDomainBlock(msgBlock)
 
+	if context.ProtocolManager.IsIBDRunning() {
+		return &appmessage.SubmitBlockResponseMessage{
+			Error:        appmessage.RPCErrorf("Block not submitted - IBD is running"),
+			RejectReason: appmessage.RejectReasonIsInIBD,
+		}, nil
+	}
+
 	err := context.ProtocolManager.AddBlock(domainBlock)
 	if err != nil {
 		if !errors.As(err, &ruleerrors.RuleError{}) {
 			return nil, err
 		}
-		errorMessage := &appmessage.SubmitBlockResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Block rejected. Reason: %s", err)
-		return errorMessage, nil
+		return &appmessage.SubmitBlockResponseMessage{
+			Error:        appmessage.RPCErrorf("Block rejected. Reason: %s", err),
+			RejectReason: appmessage.RejectReasonBlockInvalid,
+		}, nil
 	}
 
 	log.Infof("Accepted block %s via submitBlock", consensushashing.BlockHash(domainBlock))

app/rpc/rpchandlers/unban.go

@@ -0,0 +1,27 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"net"
+)
+
+// HandleUnban handles the respectively named RPC command
+func HandleUnban(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	unbanRequest := request.(*appmessage.UnbanRequestMessage)
+	ip := net.ParseIP(unbanRequest.IP)
+	if ip == nil {
+		errorMessage := &appmessage.UnbanResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Could not parse IP %s", unbanRequest.IP)
+		return errorMessage, nil
+	}
+	err := context.AddressManager.Unban(appmessage.NewNetAddressIPPort(ip, 0, 0))
+	if err != nil {
+		errorMessage := &appmessage.UnbanResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Could not unban IP: %s", err)
+		return errorMessage, nil
+	}
+	response := appmessage.NewUnbanResponseMessage()
+	return response, nil
+}

build_and_test.sh

@@ -13,14 +13,15 @@ test -z "$(go fmt ./...)"
 
 golint -set_exit_status ./...
 
-staticcheck -checks "\
-    SA4006,SA4008,SA4009,SA4010,SA5003,SA1004,SA1014,SA1021,SA1023,SA1024,SA1025,SA1026,SA1027,SA1028,SA2000,SA2001, \
-    SA2003,SA4000,SA4001,SA4003,SA4004,SA4011,SA4012,SA4013,SA4014,SA4015,SA4016,SA4017,SA4018,SA4019,SA4020,SA4021, \
-    SA4022,SA4023,SA5000,SA5002,SA5004,SA5005,SA5007,SA5008,SA5009,SA5010,SA5011,SA5012,SA6001,SA6002,SA9001,SA9002, \
-    SA9003,SA9004,SA9005,SA9006,ST1019" ./...
+staticcheck -checks SA4006,SA4008,SA4009,SA4010,SA5003,SA1004,SA1014,SA1021,SA1023,SA1024,SA1025,SA1026,SA1027,SA1028,SA2000,SA2001,SA2003,SA4000,SA4001,SA4003,SA4004,SA4011,SA4012,SA4013,SA4014,SA4015,SA4016,SA4017,SA4018,SA4019,SA4020,SA4021,SA4022,SA4023,SA5000,SA5002,SA5004,SA5005,SA5007,SA5008,SA5009,SA5010,SA5011,SA5012,SA6001,SA6002,SA9001,SA9002,SA9003,SA9004,SA9005,SA9006,ST1019 ./...
 
 go vet -composites=false $FLAGS ./...
 
 go build $FLAGS -o kaspad .
 
-go test $FLAGS ./...
+if [ -n "${NO_PARALLEL}" ]
+then
+  go test -parallel=1 $FLAGS ./...
+else
+  go test $FLAGS ./...
+fi

cmd/gencerts/gencerts.go

@@ -1,104 +0,0 @@
-// Copyright (c) 2013-2014 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"fmt"
-	"github.com/pkg/errors"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	flags "github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/util"
-)
-
-type config struct {
-	Directory    string   `short:"d" long:"directory" description:"Directory to write certificate pair"`
-	Years        int      `short:"y" long:"years" description:"How many years a certificate is valid for"`
-	Organization string   `short:"o" long:"org" description:"Organization in certificate"`
-	ExtraHosts   []string `short:"H" long:"host" description:"Additional hosts/IPs to create certificate for"`
-	Force        bool     `short:"f" long:"force" description:"Force overwriting of any old certs and keys"`
-}
-
-func main() {
-	cfg := config{
-		Years:        10,
-		Organization: "gencerts",
-	}
-	parser := flags.NewParser(&cfg, flags.Default)
-	_, err := parser.Parse()
-	if err != nil {
-		var flagsErr *flags.Error
-		if ok := errors.As(err, &flagsErr); !ok || flagsErr.Type != flags.ErrHelp {
-			parser.WriteHelp(os.Stderr)
-		}
-		return
-	}
-
-	if cfg.Directory == "" {
-		var err error
-		cfg.Directory, err = os.Getwd()
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "no directory specified and cannot get working directory\n")
-			os.Exit(1)
-		}
-	}
-	cfg.Directory = cleanAndExpandPath(cfg.Directory)
-	certFile := filepath.Join(cfg.Directory, "rpc.cert")
-	keyFile := filepath.Join(cfg.Directory, "rpc.key")
-
-	if !cfg.Force {
-		if fileExists(certFile) || fileExists(keyFile) {
-			fmt.Fprintf(os.Stderr, "%s: certificate and/or key files exist; use -f to force\n", cfg.Directory)
-			os.Exit(1)
-		}
-	}
-
-	validUntil := time.Now().Add(time.Duration(cfg.Years) * 365 * 24 * time.Hour)
-	cert, key, err := util.NewTLSCertPair(cfg.Organization, validUntil, cfg.ExtraHosts)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "cannot generate certificate pair: %s\n", err)
-		os.Exit(1)
-	}
-
-	// Write cert and key files.
-	if err = ioutil.WriteFile(certFile, cert, 0666); err != nil {
-		fmt.Fprintf(os.Stderr, "cannot write cert: %s\n", err)
-		os.Exit(1)
-	}
-	if err = ioutil.WriteFile(keyFile, key, 0600); err != nil {
-		os.Remove(certFile)
-		fmt.Fprintf(os.Stderr, "cannot write key: %s\n", err)
-		os.Exit(1)
-	}
-}
-
-// cleanAndExpandPath expands environement variables and leading ~ in the
-// passed path, cleans the result, and returns it.
-func cleanAndExpandPath(path string) string {
-	// Expand initial ~ to OS specific home directory.
-	if strings.HasPrefix(path, "~") {
-		appHomeDir := util.AppDataDir("gencerts", false)
-		homeDir := filepath.Dir(appHomeDir)
-		path = strings.Replace(path, "~", homeDir, 1)
-	}
-
-	// NOTE: The os.ExpandEnv doesn't work with Windows-style %VARIABLE%,
-	// but they variables can still be expanded via POSIX-style $VARIABLE.
-	return filepath.Clean(os.ExpandEnv(path))
-}
-
-// filesExists reports whether the named file or directory exists.
-func fileExists(name string) bool {
-	if _, err := os.Stat(name); err != nil {
-		if os.IsNotExist(err) {
-			return false
-		}
-	}
-	return true
-}

cmd/kaspactl/README.md

@@ -0,0 +1,53 @@
+# kaspactl
+
+kaspactl is an RPC client for kaspad
+
+## Requirements
+
+Go 1.15 or later.
+
+## Installation
+
+#### Build from Source
+
+- Install Go according to the installation instructions here:
+  http://golang.org/doc/install
+
+- Ensure Go was installed properly and is a supported version:
+
+```bash
+$ go version
+```
+
+- Run the following commands to obtain and install kaspad including all dependencies:
+
+```bash
+$ git clone https://github.com/kaspanet/kaspad
+$ cd kaspad/cmd/kaspactl
+$ go install .
+```
+
+- Kaspactl should now be installed in `$(go env GOPATH)/bin`. If you did not already add the bin directory to your
+  system path during Go installation, you are encouraged to do so now.
+
+## Usage
+
+The full kaspctl configuration options can be seen with:
+
+```bash
+$ kaspctl --help
+```
+
+But the minimum configuration needed to run it is:
+
+```bash
+$ kaspactl <REQUEST_JSON>
+```
+
+For example:
+
+```
+$ kaspactl '{"getBlockDagInfoRequest":{}}'
+```
+
+For a list of all available requests check out the [RPC documentation](infrastructure/network/netadapter/server/grpcserver/protowire/rpc.md)

cmd/kaspactl/command_parser.go

@@ -0,0 +1,171 @@
+package main
+
+import (
+	"reflect"
+	"strconv"
+
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/server/grpcserver/protowire"
+	"github.com/pkg/errors"
+)
+
+func parseCommand(args []string, commandDescs []*commandDescription) (*protowire.KaspadMessage, error) {
+	commandName, parameterStrings := args[0], args[1:]
+
+	var commandDesc *commandDescription
+	for _, cd := range commandDescs {
+		if cd.name == commandName {
+			commandDesc = cd
+			break
+		}
+	}
+	if commandDesc == nil {
+		return nil, errors.Errorf("unknown command: %s. Use --list-commands to list all commands", commandName)
+	}
+	if len(parameterStrings) != len(commandDesc.parameters) {
+		return nil, errors.Errorf("command '%s' expects %d parameters but got %d",
+			commandName, len(commandDesc.parameters), len(parameterStrings))
+	}
+
+	commandValue := reflect.New(unwrapCommandType(commandDesc.typeof))
+	for i, parameterDesc := range commandDesc.parameters {
+		parameterValue, err := stringToValue(parameterDesc, parameterStrings[i])
+		if err != nil {
+			return nil, err
+		}
+		setField(commandValue, parameterValue, parameterDesc)
+	}
+
+	return generateKaspadMessage(commandValue, commandDesc)
+}
+
+func setField(commandValue reflect.Value, parameterValue reflect.Value, parameterDesc *parameterDescription) {
+	parameterField := commandValue.Elem().FieldByName(parameterDesc.name)
+
+	parameterField.Set(parameterValue)
+}
+
+func stringToValue(parameterDesc *parameterDescription, valueStr string) (reflect.Value, error) {
+	var value interface{}
+	var err error
+	switch parameterDesc.typeof.Kind() {
+	case reflect.Bool:
+		value, err = strconv.ParseBool(valueStr)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+	case reflect.Int8:
+		var valueInt64 int64
+		valueInt64, err = strconv.ParseInt(valueStr, 10, 8)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+		value = int8(valueInt64)
+	case reflect.Int16:
+		var valueInt64 int64
+		valueInt64, err = strconv.ParseInt(valueStr, 10, 16)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+		value = int16(valueInt64)
+	case reflect.Int32:
+		var valueInt64 int64
+		valueInt64, err = strconv.ParseInt(valueStr, 10, 32)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+		value = int32(valueInt64)
+	case reflect.Int64:
+		value, err = strconv.ParseInt(valueStr, 10, 64)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+	case reflect.Uint8:
+		var valueUInt64 uint64
+		valueUInt64, err = strconv.ParseUint(valueStr, 10, 8)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+		value = uint8(valueUInt64)
+	case reflect.Uint16:
+		var valueUInt64 uint64
+		valueUInt64, err = strconv.ParseUint(valueStr, 10, 16)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+		value = uint16(valueUInt64)
+	case reflect.Uint32:
+		var valueUInt64 uint64
+		valueUInt64, err = strconv.ParseUint(valueStr, 10, 32)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+		value = uint32(valueUInt64)
+	case reflect.Uint64:
+		value, err = strconv.ParseUint(valueStr, 10, 64)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+	case reflect.Float32:
+		var valueFloat64 float64
+		valueFloat64, err = strconv.ParseFloat(valueStr, 32)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+		value = float32(valueFloat64)
+	case reflect.Float64:
+		value, err = strconv.ParseFloat(valueStr, 64)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+	case reflect.String:
+		value = valueStr
+	case reflect.Struct:
+		pointer := reflect.New(parameterDesc.typeof) // create pointer to this type
+		fieldInterface := pointer.Interface().(proto.Message)
+		err := protojson.Unmarshal([]byte(valueStr), fieldInterface)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+		// Unpointer the value once it's ready
+		fieldInterfaceValue := reflect.ValueOf(fieldInterface)
+		value = fieldInterfaceValue.Elem().Interface()
+	case reflect.Ptr:
+		dummyParameterDesc := &parameterDescription{
+			name:   "valuePointedTo",
+			typeof: parameterDesc.typeof.Elem(),
+		}
+		valuePointedTo, err := stringToValue(dummyParameterDesc, valueStr)
+		if err != nil {
+			return reflect.Value{}, errors.WithStack(err)
+		}
+		pointer := pointerToValue(valuePointedTo)
+
+		value = pointer.Interface()
+
+	// Int and uint are not supported because their size is platform-dependant
+	case reflect.Int,
+		reflect.Uint,
+		// Other types are not supported simply because they are not used in any command right now
+		// but support can be added if and when needed
+		reflect.Slice,
+		reflect.Func,
+		reflect.Interface,
+		reflect.Map,
+		reflect.UnsafePointer,
+		reflect.Invalid,
+		reflect.Uintptr,
+		reflect.Complex64,
+		reflect.Complex128,
+		reflect.Array,
+		reflect.Chan:
+		fallthrough
+	default:
+		return reflect.Value{},
+			errors.Errorf("Unsupported type '%s' for parameter '%s'", parameterDesc.typeof.Kind(), parameterDesc.name)
+	}
+
+	return reflect.ValueOf(value), nil
+}

cmd/kaspactl/commands.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/server/grpcserver/protowire"
+)
+
+var commandTypes = []reflect.Type{
+	reflect.TypeOf(protowire.KaspadMessage_AddPeerRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetConnectedPeerInfoRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetPeerAddressesRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetCurrentNetworkRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetInfoRequest{}),
+
+	reflect.TypeOf(protowire.KaspadMessage_GetBlockRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetBlocksRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetHeadersRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetBlockCountRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetBlockDagInfoRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetSelectedTipHashRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetVirtualSelectedParentBlueScoreRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetVirtualSelectedParentChainFromBlockRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_ResolveFinalityConflictRequest{}),
+
+	reflect.TypeOf(protowire.KaspadMessage_GetBlockTemplateRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_SubmitBlockRequest{}),
+
+	reflect.TypeOf(protowire.KaspadMessage_GetMempoolEntryRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetMempoolEntriesRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_SubmitTransactionRequest{}),
+
+	reflect.TypeOf(protowire.KaspadMessage_GetUtxosByAddressesRequest{}),
+
+	reflect.TypeOf(protowire.KaspadMessage_BanRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_UnbanRequest{}),
+}
+
+type commandDescription struct {
+	name       string
+	parameters []*parameterDescription
+	typeof     reflect.Type
+}
+
+type parameterDescription struct {
+	name   string
+	typeof reflect.Type
+}
+
+func commandDescriptions() []*commandDescription {
+	commandDescriptions := make([]*commandDescription, len(commandTypes))
+
+	for i, commandTypeWrapped := range commandTypes {
+		commandType := unwrapCommandType(commandTypeWrapped)
+
+		name := strings.TrimSuffix(commandType.Name(), "RequestMessage")
+		numFields := commandType.NumField()
+
+		var parameters []*parameterDescription
+		for i := 0; i < numFields; i++ {
+			field := commandType.Field(i)
+
+			if !isFieldExported(field) {
+				continue
+			}
+
+			parameters = append(parameters, &parameterDescription{
+				name:   field.Name,
+				typeof: field.Type,
+			})
+		}
+		commandDescriptions[i] = &commandDescription{
+			name:       name,
+			parameters: parameters,
+			typeof:     commandTypeWrapped,
+		}
+	}
+
+	return commandDescriptions
+}
+
+func (cd *commandDescription) help() string {
+	sb := &strings.Builder{}
+	sb.WriteString(cd.name)
+	for _, parameter := range cd.parameters {
+		_, _ = fmt.Fprintf(sb, " [%s]", parameter.name)
+	}
+	return sb.String()
+}

cmd/kaspactl/config.go

@@ -12,9 +12,11 @@ var (
 )
 
 type configFlags struct {
-	RPCServer   string `short:"s" long:"rpcserver" description:"RPC server to connect to"`
-	Timeout     uint64 `short:"t" long:"timeout" description:"Timeout for the request (in seconds)"`
-	RequestJSON string `description:"The request in JSON format"`
+	RPCServer            string `short:"s" long:"rpcserver" description:"RPC server to connect to"`
+	Timeout              uint64 `short:"t" long:"timeout" description:"Timeout for the request (in seconds)"`
+	RequestJSON          string `short:"j" long:"json" description:"The request in JSON format"`
+	ListCommands         bool   `short:"l" long:"list-commands" description:"List all commands and exit"`
+	CommandAndParameters []string
 	config.NetworkFlags
 }
 
@@ -23,21 +25,29 @@ func parseConfig() (*configFlags, error) {
 		RPCServer: defaultRPCServer,
 		Timeout:   defaultTimeout,
 	}
-	parser := flags.NewParser(cfg, flags.PrintErrors|flags.HelpFlag)
-	args, err := parser.Parse()
+	parser := flags.NewParser(cfg, flags.HelpFlag)
+	parser.Usage = "kaspactl [OPTIONS] [COMMAND] [COMMAND PARAMETERS].\n\nCommand can be supplied only if --json is not used." +
+		"\n\nUse `kaspactl --list-commands` to get a list of all commands and their parameters"
+	remainingArgs, err := parser.Parse()
 	if err != nil {
 		return nil, err
 	}
 
+	if cfg.ListCommands {
+		return cfg, nil
+	}
+
 	err = cfg.ResolveNetwork(parser)
 	if err != nil {
 		return nil, err
 	}
 
-	if len(args) != 1 {
-		return nil, errors.New("the last parameter must be the request in JSON format")
+	cfg.CommandAndParameters = remainingArgs
+	if len(cfg.CommandAndParameters) == 0 && cfg.RequestJSON == "" ||
+		len(cfg.CommandAndParameters) > 0 && cfg.RequestJSON != "" {
+
+		return nil, errors.New("Exactly one of --json or a command must be specified")
 	}
-	cfg.RequestJSON = args[0]
 
 	return cfg, nil
 }

cmd/kaspactl/docker/Dockerfile

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

cmd/kaspactl/main.go

@@ -2,9 +2,14 @@ package main
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/infrastructure/network/rpcclient/grpcclient"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/server/grpcserver/protowire"
 	"os"
 	"time"
+
+	"github.com/pkg/errors"
+	"google.golang.org/protobuf/encoding/protojson"
+
+	"github.com/kaspanet/kaspad/infrastructure/network/rpcclient/grpcclient"
 )
 
 func main() {
@@ -12,6 +17,10 @@ func main() {
 	if err != nil {
 		printErrorAndExit(fmt.Sprintf("error parsing command-line arguments: %s", err))
 	}
+	if cfg.ListCommands {
+		printAllCommands()
+		return
+	}
 
 	rpcAddress, err := cfg.NetParams().NormalizeRPCServerAddress(cfg.RPCServer)
 	if err != nil {
@@ -23,28 +32,69 @@ func main() {
 	}
 	defer client.Disconnect()
 
-	var responseString string
-	done := make(chan struct{})
+	responseChan := make(chan string)
 
-	go func() {
-		requestString := cfg.RequestJSON
-		var err error
-		responseString, err = client.PostJSON(requestString)
-		if err != nil {
-			printErrorAndExit(fmt.Sprintf("error posting the request to the RPC server: %s", err))
-		}
-		done <- struct{}{}
-	}()
+	if cfg.RequestJSON != "" {
+		go postJSON(cfg, client, responseChan)
+	} else {
+		go postCommand(cfg, client, responseChan)
+	}
 
 	timeout := time.Duration(cfg.Timeout) * time.Second
 	select {
-	case <-done:
-		fmt.Println(responseString)
+	case responseString := <-responseChan:
+		prettyResponseString := prettifyResponse(responseString)
+		fmt.Println(prettyResponseString)
 	case <-time.After(timeout):
 		printErrorAndExit(fmt.Sprintf("timeout of %s has been exceeded", timeout))
 	}
 }
 
+func printAllCommands() {
+	requestDescs := commandDescriptions()
+	for _, requestDesc := range requestDescs {
+		fmt.Printf("\t%s\n", requestDesc.help())
+	}
+}
+
+func postCommand(cfg *configFlags, client *grpcclient.GRPCClient, responseChan chan string) {
+	message, err := parseCommand(cfg.CommandAndParameters, commandDescriptions())
+	if err != nil {
+		printErrorAndExit(fmt.Sprintf("error parsing command: %s", err))
+	}
+
+	response, err := client.Post(message)
+	if err != nil {
+		printErrorAndExit(fmt.Sprintf("error posting the request to the RPC server: %s", err))
+	}
+	responseBytes, err := protojson.Marshal(response)
+	if err != nil {
+		printErrorAndExit(errors.Wrapf(err, "error parsing the response from the RPC server").Error())
+	}
+
+	responseChan <- string(responseBytes)
+}
+
+func postJSON(cfg *configFlags, client *grpcclient.GRPCClient, doneChan chan string) {
+	responseString, err := client.PostJSON(cfg.RequestJSON)
+	if err != nil {
+		printErrorAndExit(fmt.Sprintf("error posting the request to the RPC server: %s", err))
+	}
+	doneChan <- responseString
+}
+
+func prettifyResponse(response string) string {
+	kaspadMessage := &protowire.KaspadMessage{}
+	err := protojson.Unmarshal([]byte(response), kaspadMessage)
+	if err != nil {
+		printErrorAndExit(fmt.Sprintf("error parsing the response from the RPC server: %s", err))
+	}
+
+	marshalOptions := &protojson.MarshalOptions{}
+	marshalOptions.Indent = "    "
+	return marshalOptions.Format(kaspadMessage)
+}
+
 func printErrorAndExit(message string) {
 	fmt.Fprintf(os.Stderr, fmt.Sprintf("%s\n", message))
 	os.Exit(1)

cmd/kaspactl/reflection_helpers.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"reflect"
+	"unicode"
+
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/server/grpcserver/protowire"
+)
+
+// protobuf generates the command types with two types:
+// 1. A concrete type that holds the fields of the command bearing the name of the command with `RequestMessage` as suffix
+// 2. A wrapper that implements isKaspadMessage_Payload, having a single field pointing to the concrete command
+//    bearing the name of the command with `KaspadMessage_` prefix and `Request` suffix
+
+// unwrapCommandType converts a reflect.Type signifying a wrapper type into the concrete request type
+func unwrapCommandType(requestTypeWrapped reflect.Type) reflect.Type {
+	return requestTypeWrapped.Field(0).Type.Elem()
+}
+
+// unwrapCommandValue convertes a reflect.Value of a pointer to a wrapped command into a concrete command
+func unwrapCommandValue(commandValueWrapped reflect.Value) reflect.Value {
+	return commandValueWrapped.Elem().Field(0)
+}
+
+// isFieldExported returns true if the given field is exported.
+// Currently the only way to check this is to check if the first rune in the field's name is upper case.
+func isFieldExported(field reflect.StructField) bool {
+	return unicode.IsUpper(rune(field.Name[0]))
+}
+
+// generateKaspadMessage generates a wrapped KaspadMessage with the given `commandValue`
+func generateKaspadMessage(commandValue reflect.Value, commandDesc *commandDescription) (*protowire.KaspadMessage, error) {
+	commandWrapper := reflect.New(commandDesc.typeof)
+	unwrapCommandValue(commandWrapper).Set(commandValue)
+
+	kaspadMessage := reflect.New(reflect.TypeOf(protowire.KaspadMessage{}))
+	kaspadMessage.Elem().FieldByName("Payload").Set(commandWrapper)
+	return kaspadMessage.Interface().(*protowire.KaspadMessage), nil
+}
+
+// pointerToValue returns a reflect.Value that represents a pointer to the given value
+func pointerToValue(valuePointedTo reflect.Value) reflect.Value {
+	pointer := reflect.New(valuePointedTo.Type())
+	pointer.Elem().Set(valuePointedTo)
+	return pointer
+}

cmd/kaspaminer/README.md

@@ -0,0 +1,45 @@
+# kaspaminer
+
+Kaspaminer is a CPU-based miner for kaspad
+
+## Requirements
+
+Go 1.15 or later.
+
+## Installation
+
+#### Build from Source
+
+- Install Go according to the installation instructions here:
+  http://golang.org/doc/install
+
+- Ensure Go was installed properly and is a supported version:
+
+```bash
+$ go version
+```
+
+- Run the following commands to obtain and install kaspad including all dependencies:
+
+```bash
+$ git clone https://github.com/kaspanet/kaspad
+$ cd kaspad/cmd/kaspaminer
+$ go install .
+```
+
+- Kapaminer should now be installed in `$(go env GOPATH)/bin`. If you did
+  not already add the bin directory to your system path during Go installation,
+  you are encouraged to do so now.
+  
+## Usage
+
+The full kaspaminer configuration options can be seen with:
+
+```bash
+$ kaspaminer --help
+```
+
+But the minimum configuration needed to run it is:
+```bash
+$ kaspaminer --miningaddr=<YOUR_MINING_ADDRESS>
+```

cmd/kaspaminer/config.go

@@ -17,8 +17,9 @@ import (
 )
 
 const (
-	defaultLogFilename    = "kaspaminer.log"
-	defaultErrLogFilename = "kaspaminer_err.log"
+	defaultLogFilename          = "kaspaminer.log"
+	defaultErrLogFilename       = "kaspaminer_err.log"
+	defaultTargetBlockRateRatio = 2.0
 )
 
 var (
@@ -30,12 +31,13 @@ var (
 )
 
 type configFlags struct {
-	ShowVersion       bool   `short:"V" long:"version" description:"Display version information and exit"`
-	RPCServer         string `short:"s" long:"rpcserver" description:"RPC server to connect to"`
-	MiningAddr        string `long:"miningaddr" description:"Address to mine to"`
-	NumberOfBlocks    uint64 `short:"n" long:"numblocks" description:"Number of blocks to mine. If omitted, will mine until the process is interrupted."`
-	MineWhenNotSynced bool   `long:"mine-when-not-synced" description:"Mine even if the node is not synced with the rest of the network."`
-	Profile           string `long:"profile" description:"Enable HTTP profiling on given port -- NOTE port must be between 1024 and 65536"`
+	ShowVersion           bool     `short:"V" long:"version" description:"Display version information and exit"`
+	RPCServer             string   `short:"s" long:"rpcserver" description:"RPC server to connect to"`
+	MiningAddr            string   `long:"miningaddr" description:"Address to mine to"`
+	NumberOfBlocks        uint64   `short:"n" long:"numblocks" description:"Number of blocks to mine. If omitted, will mine until the process is interrupted."`
+	MineWhenNotSynced     bool     `long:"mine-when-not-synced" description:"Mine even if the node is not synced with the rest of the network."`
+	Profile               string   `long:"profile" description:"Enable HTTP profiling on given port -- NOTE port must be between 1024 and 65536"`
+	TargetBlocksPerSecond *float64 `long:"target-blocks-per-second" description:"Sets a maximum block rate. 0 means no limit (The default one is 2 * target network block rate)"`
 	config.NetworkFlags
 }
 
@@ -63,6 +65,11 @@ func parseConfig() (*configFlags, error) {
 		return nil, err
 	}
 
+	if cfg.TargetBlocksPerSecond == nil {
+		targetBlocksPerSecond := defaultTargetBlockRateRatio / cfg.NetParams().TargetTimePerBlock.Seconds()
+		cfg.TargetBlocksPerSecond = &targetBlocksPerSecond
+	}
+
 	if cfg.Profile != "" {
 		profilePort, err := strconv.Atoi(cfg.Profile)
 		if err != nil || profilePort < 1024 || profilePort > 65535 {
@@ -70,6 +77,10 @@ func parseConfig() (*configFlags, error) {
 		}
 	}
 
+	if cfg.MiningAddr == "" {
+		return nil, errors.New("--miningaddr is required")
+	}
+
 	initLog(defaultLogFile, defaultErrLogFile)
 
 	return cfg, nil

cmd/kaspaminer/docker/Dockerfile

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

cmd/kaspaminer/main.go

@@ -48,7 +48,7 @@ func main() {
 
 	doneChan := make(chan struct{})
 	spawn("mineLoop", func() {
-		err = mineLoop(client, cfg.NumberOfBlocks, cfg.MineWhenNotSynced, miningAddr)
+		err = mineLoop(client, cfg.NumberOfBlocks, *cfg.TargetBlocksPerSecond, cfg.MineWhenNotSynced, miningAddr)
 		if err != nil {
 			panic(errors.Wrap(err, "error in mine loop"))
 		}

cmd/kaspaminer/mineloop.go

@@ -2,12 +2,13 @@ package main
 
 import (
 	nativeerrors "errors"
+	"github.com/kaspanet/kaspad/cmd/kaspaminer/templatemanager"
+	"github.com/kaspanet/kaspad/domain/consensus/model/pow"
+	"github.com/kaspanet/kaspad/util/difficulty"
 	"math/rand"
 	"sync/atomic"
 	"time"
 
-	"github.com/kaspanet/kaspad/domain/consensus/model/pow"
-
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@@ -19,28 +20,65 @@ import (
 	"github.com/pkg/errors"
 )
 
-var random = rand.New(rand.NewSource(time.Now().UnixNano()))
 var hashesTried uint64
 
 const logHashRateInterval = 10 * time.Second
 
-func mineLoop(client *minerClient, numberOfBlocks uint64, mineWhenNotSynced bool,
+func mineLoop(client *minerClient, numberOfBlocks uint64, targetBlocksPerSecond float64, mineWhenNotSynced bool,
 	miningAddr util.Address) error {
+	rand.Seed(time.Now().UnixNano()) // Seed the global concurrent-safe random source.
 
 	errChan := make(chan error)
-
-	templateStopChan := make(chan struct{})
-
 	doneChan := make(chan struct{})
-	spawn("mineLoop-internalLoop", func() {
+
+	// We don't want to send router.DefaultMaxMessages blocks at once because there's
+	// a high chance we'll get disconnected from the node, so we make the channel
+	// capacity router.DefaultMaxMessages/2 (we give some slack for getBlockTemplate
+	// requests)
+	foundBlockChan := make(chan *externalapi.DomainBlock, router.DefaultMaxMessages/2)
+
+	spawn("templatesLoop", func() {
+		templatesLoop(client, miningAddr, errChan)
+	})
+
+	spawn("blocksLoop", func() {
+		const windowSize = 10
+		var expectedDurationForWindow time.Duration
+		var windowExpectedEndTime time.Time
+		hasBlockRateTarget := targetBlocksPerSecond != 0
+		if hasBlockRateTarget {
+			expectedDurationForWindow = time.Duration(float64(windowSize)/targetBlocksPerSecond) * time.Second
+			windowExpectedEndTime = time.Now().Add(expectedDurationForWindow)
+		}
+		blockInWindowIndex := 0
+
+		for {
+			foundBlockChan <- mineNextBlock(mineWhenNotSynced)
+
+			if hasBlockRateTarget {
+				blockInWindowIndex++
+				if blockInWindowIndex == windowSize-1 {
+					deviation := windowExpectedEndTime.Sub(time.Now())
+					if deviation > 0 {
+						log.Infof("Finished to mine %d blocks %s earlier than expected. Sleeping %s to compensate",
+							windowSize, deviation, deviation)
+						time.Sleep(deviation)
+					}
+					blockInWindowIndex = 0
+					windowExpectedEndTime = time.Now().Add(expectedDurationForWindow)
+				}
+			}
+
+		}
+	})
+
+	spawn("handleFoundBlock", func() {
 		for i := uint64(0); numberOfBlocks == 0 || i < numberOfBlocks; i++ {
-			foundBlock := make(chan *externalapi.DomainBlock)
-			mineNextBlock(client, miningAddr, foundBlock, mineWhenNotSynced, templateStopChan, errChan)
-			block := <-foundBlock
-			templateStopChan <- struct{}{}
+			block := <-foundBlockChan
 			err := handleFoundBlock(client, block)
 			if err != nil {
 				errChan <- err
+				return
 			}
 		}
 		doneChan <- struct{}{}
@@ -60,7 +98,7 @@ func logHashRate() {
 	spawn("logHashRate", func() {
 		lastCheck := time.Now()
 		for range time.Tick(logHashRateInterval) {
-			currentHashesTried := hashesTried
+			currentHashesTried := atomic.LoadUint64(&hashesTried)
 			currentTime := time.Now()
 			kiloHashesTried := float64(currentHashesTried) / 1000.0
 			hashRate := kiloHashesTried / currentTime.Sub(lastCheck).Seconds()
@@ -72,99 +110,99 @@ func logHashRate() {
 	})
 }
 
-func mineNextBlock(client *minerClient, miningAddr util.Address, foundBlock chan *externalapi.DomainBlock, mineWhenNotSynced bool,
-	templateStopChan chan struct{}, errChan chan error) {
-
-	newTemplateChan := make(chan *appmessage.GetBlockTemplateResponseMessage)
-	spawn("templatesLoop", func() {
-		templatesLoop(client, miningAddr, newTemplateChan, errChan, templateStopChan)
-	})
-	spawn("solveLoop", func() {
-		solveLoop(newTemplateChan, foundBlock, mineWhenNotSynced)
-	})
-}
-
 func handleFoundBlock(client *minerClient, block *externalapi.DomainBlock) error {
 	blockHash := consensushashing.BlockHash(block)
-	log.Infof("Found block %s with parents %s. Submitting to %s", blockHash, block.Header.ParentHashes(), client.Address())
+	log.Infof("Submitting block %s to %s", blockHash, client.Address())
 
-	err := client.SubmitBlock(block)
+	rejectReason, err := client.SubmitBlock(block)
 	if err != nil {
+		if nativeerrors.Is(err, router.ErrTimeout) {
+			log.Warnf("Got timeout while submitting block %s to %s: %s", blockHash, client.Address(), err)
+			return nil
+		}
+		if rejectReason == appmessage.RejectReasonIsInIBD {
+			const waitTime = 1 * time.Second
+			log.Warnf("Block %s was rejected because the node is in IBD. Waiting for %s", blockHash, waitTime)
+			time.Sleep(waitTime)
+			return nil
+		}
 		return errors.Errorf("Error submitting block %s to %s: %s", blockHash, client.Address(), err)
 	}
 	return nil
 }
 
-func solveBlock(block *externalapi.DomainBlock, stopChan chan struct{}, foundBlock chan *externalapi.DomainBlock) {
-	targetDifficulty := util.CompactToBig(block.Header.Bits())
-	headerForMining := block.Header.ToMutable()
-	initialNonce := random.Uint64()
-	for i := initialNonce; i != initialNonce-1; i++ {
-		select {
-		case <-stopChan:
-			return
-		default:
-			headerForMining.SetNonce(i)
-			atomic.AddUint64(&hashesTried, 1)
-			if pow.CheckProofOfWorkWithTarget(headerForMining, targetDifficulty) {
-				block.Header = headerForMining.ToImmutable()
-				foundBlock <- block
-				return
-			}
-		}
-	}
-}
-
-func templatesLoop(client *minerClient, miningAddr util.Address,
-	newTemplateChan chan *appmessage.GetBlockTemplateResponseMessage, errChan chan error, stopChan chan struct{}) {
-
-	getBlockTemplate := func() {
-		template, err := client.GetBlockTemplate(miningAddr.String())
-		if nativeerrors.Is(err, router.ErrTimeout) {
-			log.Infof("Got timeout while requesting block template from %s", client.Address())
-			return
-		} else if err != nil {
-			errChan <- errors.Errorf("Error getting block template from %s: %s", client.Address(), err)
-			return
-		}
-		newTemplateChan <- template
-	}
-	getBlockTemplate()
+func mineNextBlock(mineWhenNotSynced bool) *externalapi.DomainBlock {
+	nonce := rand.Uint64() // Use the global concurrent-safe random source.
 	for {
-		select {
-		case <-stopChan:
-			close(newTemplateChan)
-			return
-		case <-client.blockAddedNotificationChan:
-			getBlockTemplate()
-		case <-time.Tick(500 * time.Millisecond):
-			getBlockTemplate()
+		nonce++
+		// For each nonce we try to build a block from the most up to date
+		// block template.
+		// In the rare case where the nonce space is exhausted for a specific
+		// block, it'll keep looping the nonce until a new block template
+		// is discovered.
+		block := getBlockForMining(mineWhenNotSynced)
+		targetDifficulty := difficulty.CompactToBig(block.Header.Bits())
+		headerForMining := block.Header.ToMutable()
+		headerForMining.SetNonce(nonce)
+		atomic.AddUint64(&hashesTried, 1)
+		if pow.CheckProofOfWorkWithTarget(headerForMining, targetDifficulty) {
+			block.Header = headerForMining.ToImmutable()
+			log.Infof("Found block %s with parents %s", consensushashing.BlockHash(block), block.Header.ParentHashes())
+			return block
 		}
 	}
 }
 
-func solveLoop(newTemplateChan chan *appmessage.GetBlockTemplateResponseMessage, foundBlock chan *externalapi.DomainBlock,
-	mineWhenNotSynced bool) {
-
-	var stopOldTemplateSolving chan struct{}
-	for template := range newTemplateChan {
+func getBlockForMining(mineWhenNotSynced bool) *externalapi.DomainBlock {
+	tryCount := 0
+	for {
+		tryCount++
+		const sleepTime = 500 * time.Millisecond
+		shouldLog := (tryCount-1)%10 == 0
+		template := templatemanager.Get()
+		if template == nil {
+			if shouldLog {
+				log.Info("Waiting for the initial template")
+			}
+			time.Sleep(sleepTime)
+			continue
+		}
 		if !template.IsSynced && !mineWhenNotSynced {
-			log.Warnf("Kaspad is not synced. Skipping current block template")
+			if shouldLog {
+				log.Warnf("Kaspad is not synced. Skipping current block template")
+			}
+			time.Sleep(sleepTime)
 			continue
 		}
 
-		if stopOldTemplateSolving != nil {
-			close(stopOldTemplateSolving)
-		}
-
-		stopOldTemplateSolving = make(chan struct{})
-		block := appmessage.MsgBlockToDomainBlock(template.MsgBlock)
-
-		spawn("solveBlock", func() {
-			solveBlock(block, stopOldTemplateSolving, foundBlock)
-		})
-	}
-	if stopOldTemplateSolving != nil {
-		close(stopOldTemplateSolving)
+		return appmessage.MsgBlockToDomainBlock(template.MsgBlock)
+	}
+}
+
+func templatesLoop(client *minerClient, miningAddr util.Address, errChan chan error) {
+	getBlockTemplate := func() {
+		template, err := client.GetBlockTemplate(miningAddr.String())
+		if nativeerrors.Is(err, router.ErrTimeout) {
+			log.Warnf("Got timeout while requesting block template from %s: %s", client.Address(), err)
+			return
+		}
+		if err != nil {
+			errChan <- errors.Errorf("Error getting block template from %s: %s", client.Address(), err)
+			return
+		}
+		templatemanager.Set(template)
+	}
+
+	getBlockTemplate()
+	const tickerTime = 500 * time.Millisecond
+	ticker := time.NewTicker(tickerTime)
+	for {
+		select {
+		case <-client.blockAddedNotificationChan:
+			getBlockTemplate()
+			ticker.Reset(tickerTime)
+		case <-ticker.C:
+			getBlockTemplate()
+		}
 	}
 }

cmd/kaspaminer/templatemanager/templatemanager.go

@@ -0,0 +1,23 @@
+package templatemanager
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"sync"
+)
+
+var currentTemplate *appmessage.GetBlockTemplateResponseMessage
+var lock = &sync.Mutex{}
+
+// Get returns the template to work on
+func Get() *appmessage.GetBlockTemplateResponseMessage {
+	lock.Lock()
+	defer lock.Unlock()
+	return currentTemplate
+}
+
+// Set sets the current template to work on
+func Set(template *appmessage.GetBlockTemplateResponseMessage) {
+	lock.Lock()
+	defer lock.Unlock()
+	currentTemplate = template
+}

cmd/wallet/README.md

@@ -8,6 +8,35 @@ WALLET
 `wallet` is a simple, no-frills wallet software operated via the command line.\
 It is capable of generating wallet key-pairs, printing a wallet's current balance, and sending simple transactions.
 
+## Requirements
+
+Go 1.15 or later.
+
+## Installation
+
+#### Build from Source
+
+- Install Go according to the installation instructions here:
+  http://golang.org/doc/install
+
+- Ensure Go was installed properly and is a supported version:
+
+```bash
+$ go version
+```
+
+- Run the following commands to obtain and install kaspad including all dependencies:
+
+```bash
+$ git clone https://github.com/kaspanet/kaspad
+$ cd kaspad/cmd/wallet
+$ go install .
+```
+
+- Wallet should now be installed in `$(go env GOPATH)/bin`. If you did
+  not already add the bin directory to your system path during Go installation,
+  you are encouraged to do so now.
+
 
 Usage
 -----

docker/Dockerfile

@@ -1,5 +1,5 @@
 # -- multistage docker build: stage #1: build stage
-FROM golang:1.14-alpine AS build
+FROM golang:1.15-alpine AS build
 
 RUN mkdir -p /go/src/github.com/kaspanet/kaspad
 
@@ -18,7 +18,7 @@ COPY go.sum .
 
 COPY . .
 
-RUN ./build_and_test.sh
+RUN NO_PARALLEL=1 ./build_and_test.sh
 
 # --- multistage docker build: stage #2: runtime image
 FROM alpine
@@ -27,7 +27,7 @@ WORKDIR /app
 RUN apk add --no-cache ca-certificates tini
 
 COPY --from=build /go/src/github.com/kaspanet/kaspad/kaspad /app/
-COPY --from=build /go/src/github.com/kaspanet/kaspad/sample-kaspad.conf /app/
+COPY --from=build /go/src/github.com/kaspanet/kaspad/infrastructure/config/sample-kaspad.conf /app/
 
 USER nobody
 ENTRYPOINT [ "/sbin/tini", "--" ]

domain/consensus/consensus.go

@@ -1,9 +1,9 @@
 package consensus
 
 import (
-	"github.com/kaspanet/kaspad/infrastructure/db/database"
 	"sync"
 
+	"github.com/kaspanet/kaspad/domain/consensus/database"
 	"github.com/kaspanet/kaspad/domain/consensus/model"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
@@ -32,19 +32,20 @@ type consensus struct {
 	reachabilityManager   model.ReachabilityManager
 	finalityManager       model.FinalityManager
 
-	acceptanceDataStore     model.AcceptanceDataStore
-	blockStore              model.BlockStore
-	blockHeaderStore        model.BlockHeaderStore
-	pruningStore            model.PruningStore
-	ghostdagDataStore       model.GHOSTDAGDataStore
-	blockRelationStore      model.BlockRelationStore
-	blockStatusStore        model.BlockStatusStore
-	consensusStateStore     model.ConsensusStateStore
-	headersSelectedTipStore model.HeaderSelectedTipStore
-	multisetStore           model.MultisetStore
-	reachabilityDataStore   model.ReachabilityDataStore
-	utxoDiffStore           model.UTXODiffStore
-	finalityStore           model.FinalityStore
+	acceptanceDataStore       model.AcceptanceDataStore
+	blockStore                model.BlockStore
+	blockHeaderStore          model.BlockHeaderStore
+	pruningStore              model.PruningStore
+	ghostdagDataStore         model.GHOSTDAGDataStore
+	blockRelationStore        model.BlockRelationStore
+	blockStatusStore          model.BlockStatusStore
+	consensusStateStore       model.ConsensusStateStore
+	headersSelectedTipStore   model.HeaderSelectedTipStore
+	multisetStore             model.MultisetStore
+	reachabilityDataStore     model.ReachabilityDataStore
+	utxoDiffStore             model.UTXODiffStore
+	finalityStore             model.FinalityStore
+	headersSelectedChainStore model.HeadersSelectedChainStore
 }
 
 // BuildBlock builds a block over the current state, with the transactions
@@ -198,7 +199,9 @@ func (s *consensus) GetMissingBlockBodyHashes(highHash *externalapi.DomainHash)
 	return s.syncManager.GetMissingBlockBodyHashes(highHash)
 }
 
-func (s *consensus) GetPruningPointUTXOSet(expectedPruningPointHash *externalapi.DomainHash) ([]byte, error) {
+func (s *consensus) GetPruningPointUTXOs(expectedPruningPointHash *externalapi.DomainHash,
+	fromOutpoint *externalapi.DomainOutpoint, limit int) ([]*externalapi.OutpointAndUTXOEntryPair, error) {
+
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
@@ -213,11 +216,11 @@ func (s *consensus) GetPruningPointUTXOSet(expectedPruningPointHash *externalapi
 			pruningPointHash)
 	}
 
-	serializedUTXOSet, err := s.pruningStore.PruningPointSerializedUTXOSet(s.databaseContext)
+	pruningPointUTXOs, err := s.pruningStore.PruningPointUTXOs(s.databaseContext, fromOutpoint, limit)
 	if err != nil {
 		return nil, err
 	}
-	return serializedUTXOSet, nil
+	return pruningPointUTXOs, nil
 }
 
 func (s *consensus) PruningPoint() (*externalapi.DomainHash, error) {
@@ -227,11 +230,25 @@ func (s *consensus) PruningPoint() (*externalapi.DomainHash, error) {
 	return s.pruningStore.PruningPoint(s.databaseContext)
 }
 
-func (s *consensus) ValidateAndInsertPruningPoint(newPruningPoint *externalapi.DomainBlock, serializedUTXOSet []byte) error {
+func (s *consensus) ClearImportedPruningPointData() error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	return s.blockProcessor.ValidateAndInsertPruningPoint(newPruningPoint, serializedUTXOSet)
+	return s.pruningManager.ClearImportedPruningPointData()
+}
+
+func (s *consensus) AppendImportedPruningPointUTXOs(outpointAndUTXOEntryPairs []*externalapi.OutpointAndUTXOEntryPair) error {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	return s.pruningManager.AppendImportedPruningPointUTXOs(outpointAndUTXOEntryPairs)
+}
+
+func (s *consensus) ValidateAndInsertImportedPruningPoint(newPruningPoint *externalapi.DomainBlock) error {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	return s.blockProcessor.ValidateAndInsertImportedPruningPoint(newPruningPoint)
 }
 
 func (s *consensus) GetVirtualSelectedParent() (*externalapi.DomainHash, error) {
@@ -297,15 +314,29 @@ func (s *consensus) CreateBlockLocator(lowHash, highHash *externalapi.DomainHash
 	return s.syncManager.CreateBlockLocator(lowHash, highHash, limit)
 }
 
-func (s *consensus) FindNextBlockLocatorBoundaries(blockLocator externalapi.BlockLocator) (lowHash, highHash *externalapi.DomainHash, err error) {
+func (s *consensus) CreateFullHeadersSelectedChainBlockLocator() (externalapi.BlockLocator, error) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	if len(blockLocator) == 0 {
-		return nil, nil, errors.Errorf("empty block locator")
+	lowHash, err := s.pruningStore.PruningPoint(s.databaseContext)
+	if err != nil {
+		return nil, err
 	}
 
-	return s.syncManager.FindNextBlockLocatorBoundaries(blockLocator)
+	highHash, err := s.headersSelectedTipStore.HeadersSelectedTip(s.databaseContext)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.syncManager.CreateHeadersSelectedChainBlockLocator(lowHash, highHash)
+}
+
+func (s *consensus) CreateHeadersSelectedChainBlockLocator(lowHash,
+	highHash *externalapi.DomainHash) (externalapi.BlockLocator, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	return s.syncManager.CreateHeadersSelectedChainBlockLocator(lowHash, highHash)
 }
 
 func (s *consensus) GetSyncInfo() (*externalapi.SyncInfo, error) {
@@ -327,7 +358,7 @@ func (s *consensus) IsValidPruningPoint(blockHash *externalapi.DomainHash) (bool
 	return s.pruningManager.IsValidPruningPoint(blockHash)
 }
 
-func (s *consensus) GetVirtualSelectedParentChainFromBlock(blockHash *externalapi.DomainHash) (*externalapi.SelectedParentChainChanges, error) {
+func (s *consensus) GetVirtualSelectedParentChainFromBlock(blockHash *externalapi.DomainHash) (*externalapi.SelectedChainPath, error) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
@@ -372,3 +403,15 @@ func (s *consensus) GetHeadersSelectedTip() (*externalapi.DomainHash, error) {
 
 	return s.headersSelectedTipStore.HeadersSelectedTip(s.databaseContext)
 }
+
+func (s *consensus) Anticone(blockHash *externalapi.DomainHash) ([]*externalapi.DomainHash, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	err := s.validateBlockHashExists(blockHash)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.dagTraversalManager.Anticone(blockHash)
+}