fdlkjsjkldsfhjkds

.codecov.yml

@@ -5,5 +5,3 @@ coverage:
     project:
       default:
         informational: true
-ignore:
-  - "**/*.pb.go" # Ignore all auto generated protobuf structures.

.github/workflows/go-deploy.yml

@@ -1,77 +0,0 @@
-name: Build and Upload assets
-on:
-  release:
-    types: [published]
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
-    name: Building For ${{ matrix.os }}
-    steps:
-      - name: Fix windows CRLF
-        run: git config --global core.autocrlf false
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
-
-      # We need to increase the page size because the tests run out of memory on github CI windows.
-      # Use the powershell script from this github action: https://github.com/al-cheb/configure-pagefile-action/blob/master/scripts/SetPageFileSize.ps1
-      # MIT License (MIT) Copyright (c) 2020 Maxim Lobanov and contributors
-      - name: Increase page size on windows
-        if: runner.os == 'Windows'
-        shell: powershell
-        run: powershell -command .\.github\workflows\SetPageFileSize.ps1
-
-
-      - name: Set up Go 1.x
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.16
-
-      - name: Build on linux
-        if: runner.os == 'Linux'
-        # `-extldflags=-static` - means static link everything, `-tags netgo,osusergo` means use pure go replacements for "os/user" and "net"
-        # `-s -w` strips the binary to produce smaller size binaries
-        run: |
-          go build -v -ldflags="-s -w -extldflags=-static" -tags netgo,osusergo -o ./bin/ ./...
-          archive="bin/kaspad-${{ github.event.release.tag_name }}-linux.zip"
-          asset_name="kaspad-${{ github.event.release.tag_name }}-linux.zip"
-          zip -r "${archive}" ./bin/*
-          echo "archive=${archive}" >> $GITHUB_ENV
-          echo "asset_name=${asset_name}" >> $GITHUB_ENV
-
-      - name: Build on Windows
-        if: runner.os == 'Windows'
-        shell: bash
-        run: |
-          go build -v -ldflags="-s -w" -o bin/ ./...
-          archive="bin/kaspad-${{ github.event.release.tag_name }}-win64.zip"
-          asset_name="kaspad-${{ github.event.release.tag_name }}-win64.zip"
-          powershell "Compress-Archive bin/* \"${archive}\""
-          echo "archive=${archive}" >> $GITHUB_ENV
-          echo "asset_name=${asset_name}" >> $GITHUB_ENV
-
-      - name: Build on MacOS
-        if: runner.os == 'macOS'
-        run: |
-          go build -v -ldflags="-s -w" -o ./bin/ ./...
-          archive="bin/kaspad-${{ github.event.release.tag_name }}-osx.zip"
-          asset_name="kaspad-${{ github.event.release.tag_name }}-osx.zip"
-          zip -r "${archive}" ./bin/*
-          echo "archive=${archive}" >> $GITHUB_ENV
-          echo "asset_name=${asset_name}" >> $GITHUB_ENV
-
-
-      - name: Upload Release Asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ github.event.release.upload_url }}
-          asset_path: "./${{ env.archive }}"
-          asset_name: "${{ env.asset_name }}"
-          asset_content_type: application/zip

.github/workflows/go-race.yml

@@ -1,49 +0,0 @@
-name: Go-Race
-
-on:
-  schedule:
-    - cron: "0 0 * * *"
-  workflow_dispatch:
-
-jobs:
-  race_test:
-    runs-on: ubuntu-20.04
-    strategy:
-      fail-fast: false
-      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

@@ -11,7 +11,6 @@ jobs:
   build:
     runs-on: ${{ matrix.os }}
     strategy:
-      fail-fast: false
       matrix:
         os: [ ubuntu-16.04, macos-10.15 ]
     name: Testing on on ${{ matrix.os }}
@@ -35,7 +34,7 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v2
         with:
-          go-version: 1.16
+          go-version: 1.14
 
 
       # Source: https://github.com/actions/cache/blob/main/examples.md#go---modules
@@ -49,7 +48,7 @@ jobs:
 
       - name: Test
         shell: bash
-        run: ./build_and_test.sh -v
+        run: ./build_and_test.sh
 
   coverage:
     runs-on: ubuntu-20.04
@@ -61,10 +60,11 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v2
         with:
-          go-version: 1.16
+          go-version: 1.14
 
       - name: Create coverage file
-        run: go test -v -covermode=atomic -coverpkg=./... -coverprofile coverage.txt ./...
+        # Because of https://github.com/golang/go/issues/27333 this seem to "fail" even though nothing is wrong, so ignore the failure
+        run: go test -json -covermode=atomic -coverpkg=./... -coverprofile coverage.txt ./... || true
 
       - name: Upload coverage file
         run: bash <(curl -s https://codecov.io/bash)

README.md

@@ -18,7 +18,7 @@ Kaspa is an attempt at a proof-of-work cryptocurrency with instant confirmations
 
 ## Requirements
 
-Go 1.16 or later.
+Go 1.14 or later.
 
 ## Installation
 
@@ -65,7 +65,7 @@ is used for this project.
 
 ## Documentation
 
-The [documentation](https://github.com/kaspanet/docs) is a work-in-progress
+The documentation is a work-in-progress.
 
 ## License
 

app/app.go

@@ -7,20 +7,20 @@ import (
 	"runtime"
 	"time"
 
-	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/db/database"
 	"github.com/kaspanet/kaspad/infrastructure/db/database/ldb"
-	"github.com/kaspanet/kaspad/infrastructure/logger"
-	"github.com/kaspanet/kaspad/infrastructure/os/execenv"
-	"github.com/kaspanet/kaspad/infrastructure/os/limits"
+
 	"github.com/kaspanet/kaspad/infrastructure/os/signal"
-	"github.com/kaspanet/kaspad/infrastructure/os/winservice"
-	"github.com/kaspanet/kaspad/util/panics"
 	"github.com/kaspanet/kaspad/util/profiling"
 	"github.com/kaspanet/kaspad/version"
-)
 
-const leveldbCacheSizeMiB = 256
+	"github.com/kaspanet/kaspad/util/panics"
+
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/os/execenv"
+	"github.com/kaspanet/kaspad/infrastructure/os/limits"
+	"github.com/kaspanet/kaspad/infrastructure/os/winservice"
+)
 
 var desiredLimits = &limits.DesiredLimits{
 	FileLimitWant: 2048,
@@ -49,7 +49,6 @@ func StartApp() error {
 		fmt.Fprintln(os.Stderr, err)
 		return err
 	}
-	defer logger.BackendLog.Close()
 	defer panics.HandlePanic(log, "MAIN", nil)
 
 	app := &kaspadApp{cfg: cfg}
@@ -182,5 +181,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, leveldbCacheSizeMiB)
+	return ldb.NewLevelDB(dbPath)
 }

app/appmessage/domainconverters.go

@@ -3,7 +3,6 @@ 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"
@@ -164,7 +163,11 @@ func outpointToDomainOutpoint(outpoint *Outpoint) *externalapi.DomainOutpoint {
 func RPCTransactionToDomainTransaction(rpcTransaction *RPCTransaction) (*externalapi.DomainTransaction, error) {
 	inputs := make([]*externalapi.DomainTransactionInput, len(rpcTransaction.Inputs))
 	for i, input := range rpcTransaction.Inputs {
-		transactionID, err := transactionid.FromString(input.PreviousOutpoint.TransactionID)
+		transactionIDBytes, err := hex.DecodeString(input.PreviousOutpoint.TransactionID)
+		if err != nil {
+			return nil, err
+		}
+		transactionID, err := transactionid.FromBytes(transactionIDBytes)
 		if err != nil {
 			return nil, err
 		}
@@ -194,11 +197,19 @@ func RPCTransactionToDomainTransaction(rpcTransaction *RPCTransaction) (*externa
 		}
 	}
 
-	subnetworkID, err := subnetworks.FromString(rpcTransaction.SubnetworkID)
+	subnetworkIDBytes, err := hex.DecodeString(rpcTransaction.SubnetworkID)
 	if err != nil {
 		return nil, err
 	}
-	payloadHash, err := externalapi.NewDomainHashFromString(rpcTransaction.PayloadHash)
+	subnetworkID, err := subnetworks.FromBytes(subnetworkIDBytes)
+	if err != nil {
+		return nil, err
+	}
+	payloadHashBytes, err := hex.DecodeString(rpcTransaction.PayloadHash)
+	if err != nil {
+		return nil, err
+	}
+	payloadHash, err := externalapi.NewDomainHashFromByteSlice(payloadHashBytes)
 	if err != nil {
 		return nil, err
 	}
@@ -243,7 +254,7 @@ func DomainTransactionToRPCTransaction(transaction *externalapi.DomainTransactio
 			ScriptPublicKey: &RPCScriptPublicKey{Script: scriptPublicKey, Version: output.ScriptPublicKey.Version},
 		}
 	}
-	subnetworkID := transaction.SubnetworkID.String()
+	subnetworkID := hex.EncodeToString(transaction.SubnetworkID[:])
 	payloadHash := transaction.PayloadHash.String()
 	payload := hex.EncodeToString(transaction.Payload)
 	return &RPCTransaction{
@@ -257,49 +268,3 @@ 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,18 +51,17 @@ const (
 	CmdReject
 	CmdHeader
 	CmdRequestNextHeaders
-	CmdRequestPruningPointUTXOSetAndBlock
-	CmdPruningPointUTXOSetChunk
+	CmdRequestIBDRootUTXOSetAndBlock
+	CmdIBDRootUTXOSetChunk
 	CmdRequestIBDBlocks
-	CmdUnexpectedPruningPoint
-	CmdRequestPruningPointHash
-	CmdPruningPointHash
+	CmdIBDRootNotFound
+	CmdRequestIBDRootHash
+	CmdIBDRootHash
 	CmdIBDBlockLocator
 	CmdIBDBlockLocatorHighestHash
-	CmdIBDBlockLocatorHighestHashNotFound
 	CmdBlockHeaders
-	CmdRequestNextPruningPointUTXOSetChunk
-	CmdDonePruningPointUTXOSetChunks
+	CmdRequestNextIBDRootUTXOSetChunk
+	CmdDoneIBDRootUTXOSetChunks
 
 	// rpc
 	CmdGetCurrentNetworkRequestMessage
@@ -117,8 +116,6 @@ const (
 	CmdNotifyUTXOsChangedRequestMessage
 	CmdNotifyUTXOsChangedResponseMessage
 	CmdUTXOsChangedNotificationMessage
-	CmdStopNotifyingUTXOsChangedRequestMessage
-	CmdStopNotifyingUTXOsChangedResponseMessage
 	CmdGetUTXOsByAddressesRequestMessage
 	CmdGetUTXOsByAddressesResponseMessage
 	CmdGetVirtualSelectedParentBlueScoreRequestMessage
@@ -126,54 +123,42 @@ const (
 	CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage
 	CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage
 	CmdVirtualSelectedParentBlueScoreChangedNotificationMessage
-	CmdBanRequestMessage
-	CmdBanResponseMessage
-	CmdUnbanRequestMessage
-	CmdUnbanResponseMessage
-	CmdGetInfoRequestMessage
-	CmdGetInfoResponseMessage
-	CmdNotifyPruningPointUTXOSetOverrideRequestMessage
-	CmdNotifyPruningPointUTXOSetOverrideResponseMessage
-	CmdPruningPointUTXOSetOverrideNotificationMessage
-	CmdStopNotifyingPruningPointUTXOSetOverrideRequestMessage
-	CmdStopNotifyingPruningPointUTXOSetOverrideResponseMessage
 )
 
 // 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",
-	CmdRequestPruningPointUTXOSetAndBlock:  "RequestPruningPointUTXOSetAndBlock",
-	CmdPruningPointUTXOSetChunk:            "PruningPointUTXOSetChunk",
-	CmdRequestIBDBlocks:                    "RequestIBDBlocks",
-	CmdUnexpectedPruningPoint:              "UnexpectedPruningPoint",
-	CmdRequestPruningPointHash:             "RequestPruningPointHashHash",
-	CmdPruningPointHash:                    "PruningPointHash",
-	CmdIBDBlockLocator:                     "IBDBlockLocator",
-	CmdIBDBlockLocatorHighestHash:          "IBDBlockLocatorHighestHash",
-	CmdIBDBlockLocatorHighestHashNotFound:  "IBDBlockLocatorHighestHashNotFound",
-	CmdBlockHeaders:                        "BlockHeaders",
-	CmdRequestNextPruningPointUTXOSetChunk: "RequestNextPruningPointUTXOSetChunk",
-	CmdDonePruningPointUTXOSetChunks:       "DonePruningPointUTXOSetChunks",
+	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",
+	CmdIBDRootUTXOSetChunk:            "IBDRootUTXOSetChunk",
+	CmdRequestIBDBlocks:               "RequestIBDBlocks",
+	CmdIBDRootNotFound:                "IBDRootNotFound",
+	CmdRequestIBDRootHash:             "IBDRequestIBDRootHash",
+	CmdIBDRootHash:                    "IBDIBDRootHash",
+	CmdIBDBlockLocator:                "IBDBlockLocator",
+	CmdIBDBlockLocatorHighestHash:     "IBDBlockLocatorHighestHash",
+	CmdBlockHeaders:                   "BlockHeaders",
+	CmdRequestNextIBDRootUTXOSetChunk: "RequestNextIBDRootUTXOSetChunk",
+	CmdDoneIBDRootUTXOSetChunks:       "DoneIBDRootUTXOSetChunks",
 }
 
 // RPCMessageCommandToString maps all MessageCommands to their string representation
@@ -228,8 +213,6 @@ var RPCMessageCommandToString = map[MessageCommand]string{
 	CmdNotifyUTXOsChangedRequestMessage:                           "NotifyUTXOsChangedRequest",
 	CmdNotifyUTXOsChangedResponseMessage:                          "NotifyUTXOsChangedResponse",
 	CmdUTXOsChangedNotificationMessage:                            "UTXOsChangedNotification",
-	CmdStopNotifyingUTXOsChangedRequestMessage:                    "StopNotifyingUTXOsChangedRequest",
-	CmdStopNotifyingUTXOsChangedResponseMessage:                   "StopNotifyingUTXOsChangedResponse",
 	CmdGetUTXOsByAddressesRequestMessage:                          "GetUTXOsByAddressesRequest",
 	CmdGetUTXOsByAddressesResponseMessage:                         "GetUTXOsByAddressesResponse",
 	CmdGetVirtualSelectedParentBlueScoreRequestMessage:            "GetVirtualSelectedParentBlueScoreRequest",
@@ -237,17 +220,6 @@ var RPCMessageCommandToString = map[MessageCommand]string{
 	CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage:  "NotifyVirtualSelectedParentBlueScoreChangedRequest",
 	CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage: "NotifyVirtualSelectedParentBlueScoreChangedResponse",
 	CmdVirtualSelectedParentBlueScoreChangedNotificationMessage:   "VirtualSelectedParentBlueScoreChangedNotification",
-	CmdBanRequestMessage:                                          "BanRequest",
-	CmdBanResponseMessage:                                         "BanResponse",
-	CmdUnbanRequestMessage:                                        "UnbanRequest",
-	CmdUnbanResponseMessage:                                       "UnbanResponse",
-	CmdGetInfoRequestMessage:                                      "GetInfoRequest",
-	CmdGetInfoResponseMessage:                                     "GeInfoResponse",
-	CmdNotifyPruningPointUTXOSetOverrideRequestMessage:            "NotifyPruningPointUTXOSetOverrideRequest",
-	CmdNotifyPruningPointUTXOSetOverrideResponseMessage:           "NotifyPruningPointUTXOSetOverrideResponse",
-	CmdPruningPointUTXOSetOverrideNotificationMessage:             "PruningPointUTXOSetOverrideNotification",
-	CmdStopNotifyingPruningPointUTXOSetOverrideRequestMessage:     "StopNotifyingPruningPointUTXOSetOverrideRequest",
-	CmdStopNotifyingPruningPointUTXOSetOverrideResponseMessage:    "StopNotifyingPruningPointUTXOSetOverrideResponse",
 }
 
 // Message is an interface that describes a kaspa message. A type that

app/appmessage/p2p_ibdrootnotfound.go

@@ -0,0 +1,22 @@
+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,11 +11,15 @@ 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 := uint64(0xba4d87a69924a93d)
+	nonce, err := random.Uint64()
+	if err != nil {
+		t.Errorf("random.Uint64: Error generating nonce: %v", err)
+	}
 
 	hashes := []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash}
 

app/appmessage/p2p_msgdoneibdrootutxosetchunks.go

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

app/appmessage/p2p_msgdonepruningpointutxosetchunks.go

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

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

@@ -0,0 +1,26 @@
+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_msgibdrootutxosetchunk.go

@@ -0,0 +1,19 @@
+package appmessage
+
+// MsgIBDRootUTXOSetChunk represents a kaspa IBDRootUTXOSetChunk message
+type MsgIBDRootUTXOSetChunk struct {
+	baseMessage
+	Chunk []byte
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgIBDRootUTXOSetChunk) Command() MessageCommand {
+	return CmdIBDRootUTXOSetChunk
+}
+
+// NewMsgIBDRootUTXOSetChunk returns a new MsgIBDRootUTXOSetChunk.
+func NewMsgIBDRootUTXOSetChunk(chunk []byte) *MsgIBDRootUTXOSetChunk {
+	return &MsgIBDRootUTXOSetChunk{
+		Chunk: chunk,
+	}
+}

app/appmessage/p2p_msgping_test.go

@@ -6,12 +6,17 @@ 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 := uint64(0x61c2c5535902862)
+	nonce, err := random.Uint64()
+	if err != nil {
+		t.Errorf("random.Uint64: Error generating nonce: %v", err)
+	}
 	msg := NewMsgPing(nonce)
 	if msg.Nonce != nonce {
 		t.Errorf("NewMsgPing: wrong nonce - got %v, want %v",

app/appmessage/p2p_msgpong_test.go

@@ -6,11 +6,16 @@ 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 := uint64(0x1a05b581a5182c)
+	nonce, err := random.Uint64()
+	if err != nil {
+		t.Errorf("random.Uint64: error generating nonce: %v", err)
+	}
 	msg := NewMsgPong(nonce)
 	if msg.Nonce != nonce {
 		t.Errorf("NewMsgPong: wrong nonce - got %v, want %v",

app/appmessage/p2p_msgpruningpointhash.go

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

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

@@ -0,0 +1,26 @@
+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_msgrequestnextibdrootutxosetchunk.go

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

app/appmessage/p2p_msgrequestnextpruningpointutxosetchunk.go

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

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

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

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

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

@@ -1,39 +0,0 @@
-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,6 +5,7 @@ package appmessage
 type GetBlockRequestMessage struct {
 	baseMessage
 	Hash                          string
+	SubnetworkID                  string
 	IncludeTransactionVerboseData bool
 }
 
@@ -14,9 +15,10 @@ func (msg *GetBlockRequestMessage) Command() MessageCommand {
 }
 
 // NewGetBlockRequestMessage returns a instance of the message
-func NewGetBlockRequestMessage(hash string, includeTransactionVerboseData bool) *GetBlockRequestMessage {
+func NewGetBlockRequestMessage(hash string, subnetworkID string, includeTransactionVerboseData bool) *GetBlockRequestMessage {
 	return &GetBlockRequestMessage{
 		Hash:                          hash,
+		SubnetworkID:                  subnetworkID,
 		IncludeTransactionVerboseData: includeTransactionVerboseData,
 	}
 }
@@ -55,7 +57,6 @@ type BlockVerboseData struct {
 	Bits                   string
 	Difficulty             float64
 	ParentHashes           []string
-	ChildrenHashes         []string
 	SelectedParentHash     string
 	BlueScore              uint64
 	IsHeaderOnly           bool
@@ -105,5 +106,4 @@ type ScriptPubKeyResult struct {
 	Hex     string
 	Type    string
 	Address string
-	Version uint16
 }

app/appmessage/rpc_get_block_dag_info.go

@@ -27,7 +27,6 @@ type GetBlockDAGInfoResponseMessage struct {
 	VirtualParentHashes []string
 	Difficulty          float64
 	PastMedianTime      int64
-	PruningPointHash    string
 
 	Error *RPCError
 }

app/appmessage/rpc_get_blocks.go

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

app/appmessage/rpc_get_info.go

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

app/appmessage/rpc_notify_pruning_point_utxo_set_override.go

@@ -1,83 +0,0 @@
-package appmessage
-
-// NotifyPruningPointUTXOSetOverrideRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyPruningPointUTXOSetOverrideRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyPruningPointUTXOSetOverrideRequestMessage) Command() MessageCommand {
-	return CmdNotifyPruningPointUTXOSetOverrideRequestMessage
-}
-
-// NewNotifyPruningPointUTXOSetOverrideRequestMessage returns a instance of the message
-func NewNotifyPruningPointUTXOSetOverrideRequestMessage() *NotifyPruningPointUTXOSetOverrideRequestMessage {
-	return &NotifyPruningPointUTXOSetOverrideRequestMessage{}
-}
-
-// NotifyPruningPointUTXOSetOverrideResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyPruningPointUTXOSetOverrideResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyPruningPointUTXOSetOverrideResponseMessage) Command() MessageCommand {
-	return CmdNotifyPruningPointUTXOSetOverrideResponseMessage
-}
-
-// NewNotifyPruningPointUTXOSetOverrideResponseMessage returns a instance of the message
-func NewNotifyPruningPointUTXOSetOverrideResponseMessage() *NotifyPruningPointUTXOSetOverrideResponseMessage {
-	return &NotifyPruningPointUTXOSetOverrideResponseMessage{}
-}
-
-// PruningPointUTXOSetOverrideNotificationMessage is an appmessage corresponding to
-// its respective RPC message
-type PruningPointUTXOSetOverrideNotificationMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *PruningPointUTXOSetOverrideNotificationMessage) Command() MessageCommand {
-	return CmdPruningPointUTXOSetOverrideNotificationMessage
-}
-
-// NewPruningPointUTXOSetOverrideNotificationMessage returns a instance of the message
-func NewPruningPointUTXOSetOverrideNotificationMessage() *PruningPointUTXOSetOverrideNotificationMessage {
-	return &PruningPointUTXOSetOverrideNotificationMessage{}
-}
-
-// StopNotifyingPruningPointUTXOSetOverrideRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type StopNotifyingPruningPointUTXOSetOverrideRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *StopNotifyingPruningPointUTXOSetOverrideRequestMessage) Command() MessageCommand {
-	return CmdNotifyPruningPointUTXOSetOverrideRequestMessage
-}
-
-// NewStopNotifyingPruningPointUTXOSetOverrideRequestMessage returns a instance of the message
-func NewStopNotifyingPruningPointUTXOSetOverrideRequestMessage() *StopNotifyingPruningPointUTXOSetOverrideRequestMessage {
-	return &StopNotifyingPruningPointUTXOSetOverrideRequestMessage{}
-}
-
-// StopNotifyingPruningPointUTXOSetOverrideResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type StopNotifyingPruningPointUTXOSetOverrideResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *StopNotifyingPruningPointUTXOSetOverrideResponseMessage) Command() MessageCommand {
-	return CmdNotifyPruningPointUTXOSetOverrideResponseMessage
-}
-
-// NewStopNotifyingPruningPointUTXOSetOverrideResponseMessage returns a instance of the message
-func NewStopNotifyingPruningPointUTXOSetOverrideResponseMessage() *StopNotifyingPruningPointUTXOSetOverrideResponseMessage {
-	return &StopNotifyingPruningPointUTXOSetOverrideResponseMessage{}
-}

app/appmessage/rpc_stop_notifying_utxos_changed.go

@@ -1,37 +0,0 @@
-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_unban.go

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

@@ -90,18 +90,14 @@ func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database,
 		return nil, err
 	}
 
-	addressManager, err := addressmanager.New(addressmanager.NewConfig(cfg), db)
+	addressManager, err := addressmanager.New(addressmanager.NewConfig(cfg))
 	if err != nil {
 		return nil, err
 	}
 
 	var utxoIndex *utxoindex.UTXOIndex
 	if cfg.UTXOIndex {
-		utxoIndex, err = utxoindex.New(domain.Consensus(), db)
-		if err != nil {
-			return nil, err
-		}
-
+		utxoIndex = utxoindex.New(domain.Consensus(), db)
 		log.Infof("UTXO index started")
 	}
 
@@ -148,7 +144,6 @@ func setupRPC(
 		shutDownChan,
 	)
 	protocolManager.SetOnBlockAddedToDAGHandler(rpcManager.NotifyBlockAddedToDAG)
-	protocolManager.SetOnPruningPointUTXOSetOverrideHandler(rpcManager.NotifyPruningPointUTXOSetOverride)
 
 	return rpcManager
 }

app/log.go

@@ -7,6 +7,8 @@ package app
 
 import (
 	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/util/panics"
 )
 
-var log = logger.RegisterSubSystem("KASD")
+var log, _ = logger.Get(logger.SubsystemTags.KASD)
+var spawn = panics.GoroutineWrapperFunc(log)

app/protocol/blocklogger/blocklogger.go

@@ -0,0 +1,58 @@
+// 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/blocklogger/log.go

@@ -8,4 +8,4 @@ import (
 	"github.com/kaspanet/kaspad/infrastructure/logger"
 )
 
-var log = logger.RegisterSubSystem("BDAG")
+var log, _ = logger.Get(logger.SubsystemTags.PROT)

app/protocol/flowcontext/blocks.go

@@ -1,8 +1,8 @@
 package flowcontext
 
 import (
+	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/pkg/errors"
 
@@ -38,6 +38,8 @@ 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)
 		_, err = f.Domain().MiningManager().HandleNewBlockTransactions(newBlock.Transactions)
 		if err != nil {
@@ -57,15 +59,6 @@ func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock,
 	return nil
 }
 
-// OnPruningPointUTXOSetOverride calls the handler function whenever the UTXO set
-// resets due to pruning point change via IBD.
-func (f *FlowContext) OnPruningPointUTXOSetOverride() error {
-	if f.onPruningPointUTXOSetOverrideHandler != nil {
-		return f.onPruningPointUTXOSetOverrideHandler()
-	}
-	return nil
-}
-
 func (f *FlowContext) broadcastTransactionsAfterBlockAdded(
 	block *externalapi.DomainBlock, transactionsAcceptedToMempool []*externalapi.DomainTransaction) error {
 
@@ -108,10 +101,6 @@ func (f *FlowContext) SharedRequestedBlocks() *blockrelay.SharedRequestedBlocks
 
 // AddBlock adds the given block to the DAG and propagates it.
 func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
-	if len(block.Transactions) == 0 {
-		return protocolerrors.Errorf(false, "cannot add header only block")
-	}
-
 	blockInsertionResult, err := f.Domain().Consensus().ValidateAndInsertBlock(block)
 	if err != nil {
 		if errors.As(err, &ruleerrors.RuleError{}) {

app/protocol/flowcontext/errors.go

@@ -18,11 +18,11 @@ import (
 func (*FlowContext) HandleError(err error, flowName string, isStopping *uint32, errChan chan<- error) {
 	isErrRouteClosed := errors.Is(err, router.ErrRouteClosed)
 	if !isErrRouteClosed {
-		if protocolErr := (protocolerrors.ProtocolError{}); !errors.As(err, &protocolErr) {
+		if protocolErr := &(protocolerrors.ProtocolError{}); !errors.As(err, &protocolErr) {
 			panic(err)
 		}
 
-		log.Errorf("error from %s: %s", flowName, err)
+		log.Errorf("error from %s: %+v", flowName, err)
 	}
 
 	if atomic.AddUint32(isStopping, 1) == 1 {

app/protocol/flowcontext/flow_context.go

@@ -23,10 +23,6 @@ import (
 // when a block is added to the DAG
 type OnBlockAddedToDAGHandler func(block *externalapi.DomainBlock, blockInsertionResult *externalapi.BlockInsertionResult) error
 
-// OnPruningPointUTXOSetOverrideHandler is a handle function that's triggered whenever the UTXO set
-// resets due to pruning point change via IBD.
-type OnPruningPointUTXOSetOverrideHandler func() error
-
 // OnTransactionAddedToMempoolHandler is a handler function that's triggered
 // when a transaction is added to the mempool
 type OnTransactionAddedToMempoolHandler func()
@@ -42,9 +38,8 @@ type FlowContext struct {
 
 	timeStarted int64
 
-	onBlockAddedToDAGHandler             OnBlockAddedToDAGHandler
-	onPruningPointUTXOSetOverrideHandler OnPruningPointUTXOSetOverrideHandler
-	onTransactionAddedToMempoolHandler   OnTransactionAddedToMempoolHandler
+	onBlockAddedToDAGHandler           OnBlockAddedToDAGHandler
+	onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler
 
 	transactionsToRebroadcastLock sync.Mutex
 	transactionsToRebroadcast     map[externalapi.DomainTransactionID]*externalapi.DomainTransaction
@@ -87,11 +82,6 @@ func (f *FlowContext) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler OnBlo
 	f.onBlockAddedToDAGHandler = onBlockAddedToDAGHandler
 }
 
-// SetOnPruningPointUTXOSetOverrideHandler sets the onPruningPointUTXOSetOverrideHandler handler
-func (f *FlowContext) SetOnPruningPointUTXOSetOverrideHandler(onPruningPointUTXOSetOverrideHandler OnPruningPointUTXOSetOverrideHandler) {
-	f.onPruningPointUTXOSetOverrideHandler = onPruningPointUTXOSetOverrideHandler
-}
-
 // SetOnTransactionAddedToMempoolHandler sets the onTransactionAddedToMempool handler
 func (f *FlowContext) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler) {
 	f.onTransactionAddedToMempoolHandler = onTransactionAddedToMempoolHandler

app/protocol/flowcontext/log.go

@@ -2,6 +2,8 @@ package flowcontext
 
 import (
 	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/util/panics"
 )
 
-var log = logger.RegisterSubSystem("PROT")
+var log, _ = logger.Get(logger.SubsystemTags.PROT)
+var spawn = panics.GoroutineWrapperFunc(log)

app/protocol/flowcontext/orphans.go

@@ -4,8 +4,6 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/hashset"
-	"github.com/kaspanet/kaspad/infrastructure/logger"
 	"github.com/pkg/errors"
 )
 
@@ -162,52 +160,3 @@ 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 = 60 * 60 * 1000 // 1 Hour
+	maxSelectedParentTimeDiffToAllowMiningInMilliSeconds = 300_000
 )
 
 // ShouldMine returns whether it's ok to use block template from this node

app/protocol/flows/addressexchange/receiveaddresses.go

@@ -5,12 +5,14 @@ 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
 }
 
@@ -35,5 +37,6 @@ func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Rou
 		return protocolerrors.Errorf(true, "address count exceeded %d", addressmanager.GetAddressesMax)
 	}
 
-	return context.AddressManager().AddAddresses(msgAddresses.AddressList...)
+	context.AddressManager().AddAddresses(msgAddresses.AddressList...)
+	return nil
 }

app/protocol/flows/addressexchange/sendaddresses.go

@@ -1,6 +1,7 @@
 package addressexchange
 
 import (
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"math/rand"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
@@ -16,11 +17,16 @@ type SendAddressesContext interface {
 // SendAddresses sends addresses to a peer that requests it.
 func SendAddresses(context SendAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
 	for {
-		_, err := incomingRoute.Dequeue()
+		message, 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,14 +70,8 @@ func HandleIBDBlockLocator(context HandleIBDBlockLocatorContext, incomingRoute *
 		}
 
 		if !foundHighestHashInTheSelectedParentChainOfTargetHash {
-			log.Warnf("no hash was found in the blockLocator "+
+			return protocolerrors.Errorf(true, "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_root_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"
+)
+
+// 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
+		}
+		log.Debugf("Got request for IBD root hash")
+
+		pruningPoint, err := flow.Domain().Consensus().PruningPoint()
+		if err != nil {
+			return err
+		}
+
+		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDRootHashMessage(pruningPoint))
+		if err != nil {
+			return err
+		}
+		log.Debugf("Sent IBD root hash %s", pruningPoint)
+	}
+}

app/protocol/flows/blockrelay/handle_pruning_point_hash_requests.go

@@ -1,51 +0,0 @@
-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_invs.go

@@ -10,6 +10,7 @@ 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"
 )
@@ -23,12 +24,11 @@ var orphanResolutionRange uint32 = 5
 type RelayInvsContext interface {
 	Domain() domain.Domain
 	Config() *config.Config
+	NetAdapter() *netadapter.NetAdapter
 	OnNewBlock(block *externalapi.DomainBlock, blockInsertionResult *externalapi.BlockInsertionResult) error
-	OnPruningPointUTXOSetOverride() 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(ibdPeer *peerpkg.Peer) bool
@@ -71,7 +71,7 @@ func (flow *handleRelayInvsFlow) start() error {
 		if err != nil {
 			return err
 		}
-		if blockInfo.Exists && blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
+		if blockInfo.Exists {
 			if blockInfo.BlockStatus == externalapi.StatusInvalid {
 				return protocolerrors.Errorf(true, "sent inv of an invalid block %s",
 					inv.Hash)
@@ -81,11 +81,7 @@ func (flow *handleRelayInvsFlow) start() error {
 		}
 
 		if flow.IsOrphan(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
-			}
+			log.Debugf("Block %s is a known orphan. continuing...", inv.Hash)
 			continue
 		}
 
@@ -105,27 +101,13 @@ func (flow *handleRelayInvsFlow) start() error {
 			continue
 		}
 
-		err = flow.banIfBlockIsHeaderOnly(block)
-		if err != nil {
-			return err
-		}
-
 		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 is orphan and has missing parents: %s", inv.Hash, missingParents)
+			log.Debugf("Block %s contains orphans: %s", inv.Hash, missingParents)
 			err := flow.processOrphan(block, missingParents)
 			if err != nil {
 				return err
@@ -146,15 +128,6 @@ func (flow *handleRelayInvsFlow) start() error {
 	}
 }
 
-func (flow *handleRelayInvsFlow) banIfBlockIsHeaderOnly(block *externalapi.DomainBlock) error {
-	if len(block.Transactions) == 0 {
-		return protocolerrors.Errorf(true, "sent header of %s block where expected block with body",
-			consensushashing.BlockHash(block))
-	}
-
-	return nil
-}
-
 func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error) {
 	if len(flow.invsQueue) > 0 {
 		var inv *appmessage.MsgInvRelayBlock
@@ -265,10 +238,9 @@ 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", blockHash)
-		flow.AddOrphan(block)
-		log.Debugf("Requesting block %s missing ancestors", blockHash)
-		return flow.AddOrphanRootsToQueue(blockHash)
+			"Adding it to the orphan set and requesting its missing parents", blockHash)
+		flow.addToOrphanSetAndRequestMissingParents(block, missingParents)
+		return nil
 	}
 
 	// Start IBD unless we already are in IBD
@@ -305,25 +277,13 @@ func (flow *handleRelayInvsFlow) isBlockInOrphanResolutionRange(blockHash *exter
 	return false, nil
 }
 
-func (flow *handleRelayInvsFlow) AddOrphanRootsToQueue(orphan *externalapi.DomainHash) error {
-	orphanRoots, orphanExists, err := flow.GetOrphanRoots(orphan)
-	if err != nil {
-		return err
+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)
 	}
-
-	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_headers.go

@@ -17,7 +17,7 @@ type RequestIBDBlocksContext interface {
 	Domain() domain.Domain
 }
 
-type handleRequestHeadersFlow struct {
+type handleRequestBlocksFlow struct {
 	RequestIBDBlocksContext
 	incomingRoute, outgoingRoute *router.Route
 	peer                         *peer.Peer
@@ -27,7 +27,7 @@ type handleRequestHeadersFlow struct {
 func HandleRequestHeaders(context RequestIBDBlocksContext, incomingRoute *router.Route,
 	outgoingRoute *router.Route, peer *peer.Peer) error {
 
-	flow := &handleRequestHeadersFlow{
+	flow := &handleRequestBlocksFlow{
 		RequestIBDBlocksContext: context,
 		incomingRoute:           incomingRoute,
 		outgoingRoute:           outgoingRoute,
@@ -36,7 +36,7 @@ func HandleRequestHeaders(context RequestIBDBlocksContext, incomingRoute *router
 	return flow.start()
 }
 
-func (flow *handleRequestHeadersFlow) start() error {
+func (flow *handleRequestBlocksFlow) start() error {
 	for {
 		lowHash, highHash, err := receiveRequestHeaders(flow.incomingRoute)
 		if err != nil {

app/protocol/flows/blockrelay/handle_request_ibd_root_utxo_set_and_block.go

@@ -0,0 +1,117 @@
+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/ruleerrors"
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"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, ok := message.(*appmessage.MsgRequestIBDRootUTXOSetAndBlock)
+		if !ok {
+			return protocolerrors.Errorf(true, "received unexpected message type. "+
+				"expected: %s, got: %s", appmessage.CmdRequestIBDRootUTXOSetAndBlock, message.Command())
+		}
+
+		finishMeasuring := logger.LogAndMeasureExecutionTime(log, "handleRequestIBDRootUTXOSetAndBlockFlow")
+		log.Debugf("Got request for IBDRoot UTXOSet and Block")
+
+		serializedUTXOSet, 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
+			}
+		}
+		log.Debugf("Retrieved utxo set for pruning block %s", msgRequestIBDRootUTXOSetAndBlock.IBDRoot)
+
+		block, err := flow.Domain().Consensus().GetBlock(msgRequestIBDRootUTXOSetAndBlock.IBDRoot)
+		if err != nil {
+			return err
+		}
+		log.Debugf("Retrieved pruning block %s", msgRequestIBDRootUTXOSetAndBlock.IBDRoot)
+
+		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDBlock(appmessage.DomainBlockToMsgBlock(block)))
+		if err != nil {
+			return err
+		}
+
+		// Send the UTXO set in `step`-sized chunks
+		const step = 1024 * 1024 // 1MB
+		offset := 0
+		chunksSent := 0
+		for offset < len(serializedUTXOSet) {
+			var chunk []byte
+			if offset+step < len(serializedUTXOSet) {
+				chunk = serializedUTXOSet[offset : offset+step]
+			} else {
+				chunk = serializedUTXOSet[offset:]
+			}
+
+			err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDRootUTXOSetChunk(chunk))
+			if err != nil {
+				return err
+			}
+
+			offset += step
+			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.MsgRequestNextIBDRootUTXOSetChunk)
+				if !ok {
+					return protocolerrors.Errorf(true, "received unexpected message type. "+
+						"expected: %s, got: %s", appmessage.CmdRequestNextIBDRootUTXOSetChunk, message.Command())
+				}
+			}
+		}
+
+		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgDoneIBDRootUTXOSetChunks())
+		if err != nil {
+			return err
+		}
+
+		finishMeasuring()
+	}
+}

app/protocol/flows/blockrelay/handle_request_pruning_point_utxo_set_and_block.go

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

@@ -1,10 +1,8 @@
 package blockrelay
 
 import (
-	"fmt"
-	"time"
-
 	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"time"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model"
 
@@ -28,14 +26,10 @@ func (flow *handleRelayInvsFlow) runIBDIfNotRunning(highHash *externalapi.Domain
 	log.Debugf("IBD started with peer %s and highHash %s", flow.peer, highHash)
 
 	log.Debugf("Syncing headers up to %s", highHash)
-	headersSynced, err := flow.syncHeaders(highHash)
+	err := flow.syncHeaders(highHash)
 	if err != nil {
 		return err
 	}
-	if !headersSynced {
-		log.Debugf("Aborting IBD because the headers failed to sync")
-		return nil
-	}
 	log.Debugf("Finished syncing headers up to %s", highHash)
 
 	log.Debugf("Syncing the current pruning point UTXO set")
@@ -59,61 +53,47 @@ func (flow *handleRelayInvsFlow) runIBDIfNotRunning(highHash *externalapi.Domain
 	return nil
 }
 
-// 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
-	}
-	if !highestSharedBlockFound {
-		return false, nil
-	}
-	log.Debugf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
+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 false, err
-	}
+		err = flow.downloadHeaders(highestSharedBlockHash, highHash)
+		if err != nil {
+			return 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
+		// 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)
 	}
-	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
+	return nil
 }
 
-// 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) {
-
+func (flow *handleRelayInvsFlow) findHighestSharedBlockHash(targetHash *externalapi.DomainHash) (*externalapi.DomainHash, error) {
 	log.Debugf("Sending a blockLocator to %s between pruning point and headers selected tip", flow.peer)
 	blockLocator, err := flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
 	if err != nil {
-		return nil, false, err
+		return nil, err
 	}
 
 	for {
-		highestHash, highestHashFound, err := flow.fetchHighestHash(targetHash, blockLocator)
+		highestHash, err := flow.fetchHighestHash(targetHash, blockLocator)
 		if err != nil {
-			return nil, false, err
-		}
-		if !highestHashFound {
-			return nil, false, nil
+			return nil, err
 		}
 		highestHashIndex, err := flow.findHighestHashIndex(highestHash, blockLocator)
 		if err != nil {
-			return nil, false, err
+			return nil, err
 		}
 
 		if highestHashIndex == 0 ||
@@ -122,7 +102,7 @@ func (flow *handleRelayInvsFlow) findHighestSharedBlockHash(
 			// an endless loop, we explicitly stop the loop in such situation.
 			(len(blockLocator) == 2 && highestHashIndex == 1) {
 
-			return highestHash, true, nil
+			return highestHash, nil
 		}
 
 		locatorHashAboveHighestHash := highestHash
@@ -132,7 +112,7 @@ func (flow *handleRelayInvsFlow) findHighestSharedBlockHash(
 
 		blockLocator, err = flow.nextBlockLocator(highestHash, locatorHashAboveHighestHash)
 		if err != nil {
-			return nil, false, err
+			return nil, err
 		}
 	}
 }
@@ -177,35 +157,27 @@ func (flow *handleRelayInvsFlow) findHighestHashIndex(
 	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) {
+	targetHash *externalapi.DomainHash, blockLocator externalapi.BlockLocator) (*externalapi.DomainHash, error) {
 
 	ibdBlockLocatorMessage := appmessage.NewMsgIBDBlockLocator(targetHash, blockLocator)
 	err := flow.outgoingRoute.Enqueue(ibdBlockLocatorMessage)
 	if err != nil {
-		return nil, false, err
+		return nil, err
 	}
 	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
 	if err != nil {
-		return nil, false, err
+		return nil, err
 	}
-	switch message := message.(type) {
-	case *appmessage.MsgIBDBlockLocatorHighestHash:
-		highestHash := message.HighestHash
-		log.Debugf("The highest hash the peer %s knows is %s", flow.peer, highestHash)
-
-		return highestHash, true, nil
-	case *appmessage.MsgIBDBlockLocatorHighestHashNotFound:
-		log.Debugf("Peer %s does not know any block within our blockLocator. "+
-			"This should only happen if there's a DAG split deeper than the pruning point.", flow.peer)
-		return nil, false, nil
-	default:
-		return nil, false, protocolerrors.Errorf(true, "received unexpected message type. "+
+	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)
+
+	return highestHash, nil
 }
 
 func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externalapi.DomainHash,
@@ -221,6 +193,7 @@ 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()
@@ -229,7 +202,7 @@ func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externa
 				return
 			}
 			if doneIBD {
-				close(blockHeadersMessageChan)
+				doneChan <- struct{}{}
 				return
 			}
 
@@ -245,10 +218,7 @@ func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externa
 
 	for {
 		select {
-		case blockHeadersMessage, ok := <-blockHeadersMessageChan:
-			if !ok {
-				return nil
-			}
+		case blockHeadersMessage := <-blockHeadersMessageChan:
 			for _, header := range blockHeadersMessage.BlockHeaders {
 				err = flow.processHeader(header)
 				if err != nil {
@@ -257,6 +227,8 @@ func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externa
 			}
 		case err := <-errChan:
 			return err
+		case <-doneChan:
+			return nil
 		}
 	}
 }
@@ -306,13 +278,9 @@ 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)
 
-		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 protocolerrors.Wrapf(true, err, "got invalid block %s during IBD", blockHash)
 	}
 
 	return nil
@@ -320,7 +288,7 @@ func (flow *handleRelayInvsFlow) processHeader(msgBlockHeader *appmessage.MsgBlo
 
 func (flow *handleRelayInvsFlow) syncPruningPointUTXOSet() (bool, error) {
 	log.Debugf("Checking if a new pruning point is available")
-	err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestPruningPointHashMessage())
+	err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDRootHashMessage())
 	if err != nil {
 		return false, err
 	}
@@ -328,40 +296,36 @@ func (flow *handleRelayInvsFlow) syncPruningPointUTXOSet() (bool, error) {
 	if err != nil {
 		return false, err
 	}
-	msgPruningPointHash, ok := message.(*appmessage.MsgPruningPointHashMessage)
+	msgIBDRootHash, ok := message.(*appmessage.MsgIBDRootHashMessage)
 	if !ok {
 		return false, protocolerrors.Errorf(true, "received unexpected message type. "+
-			"expected: %s, got: %s", appmessage.CmdPruningPointHash, message.Command())
+			"expected: %s, got: %s", appmessage.CmdIBDRootHash, message.Command())
 	}
 
-	blockInfo, err := flow.Domain().Consensus().GetBlockInfo(msgPruningPointHash.Hash)
+	blockInfo, err := flow.Domain().Consensus().GetBlockInfo(msgIBDRootHash.Hash)
 	if err != nil {
 		return false, err
 	}
 
-	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)
+		log.Debugf("Already has the block data of the new suggested pruning point %s", msgIBDRootHash.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)
+	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 false, err
 	}
 
 	if !isValid {
 		log.Infof("The suggested pruning point %s is incompatible to this node DAG, so stopping IBD with this"+
-			" peer", msgPruningPointHash.Hash)
+			" peer", msgIBDRootHash.Hash)
 		return false, nil
 	}
 
 	log.Info("Fetching the pruning point UTXO set")
-	succeed, err := flow.fetchMissingUTXOSet(msgPruningPointHash.Hash)
+	succeed, err := flow.fetchMissingUTXOSet(msgIBDRootHash.Hash)
 	if err != nil {
 		return false, err
 	}
@@ -375,123 +339,94 @@ func (flow *handleRelayInvsFlow) syncPruningPointUTXOSet() (bool, error) {
 	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))
+func (flow *handleRelayInvsFlow) fetchMissingUTXOSet(ibdRootHash *externalapi.DomainHash) (succeed bool, err error) {
+	err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDRootUTXOSetAndBlock(ibdRootHash))
 	if err != nil {
 		return false, err
 	}
 
-	block, err := flow.receivePruningPointBlock()
+	utxoSet, block, found, err := flow.receiveIBDRootUTXOSetAndBlock()
 	if err != nil {
 		return false, err
 	}
 
-	receivedAll, err := flow.receiveAndInsertPruningPointUTXOSet(pruningPointHash)
-	if err != nil {
-		return false, err
-	}
-	if !receivedAll {
+	if !found {
 		return false, nil
 	}
 
-	err = flow.Domain().Consensus().ValidateAndInsertImportedPruningPoint(block)
+	err = flow.Domain().Consensus().ValidateAndInsertPruningPoint(block, utxoSet)
 	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 pruning point UTXO set")
-	}
-
-	err = flow.OnPruningPointUTXOSetOverride()
-	if err != nil {
-		return false, err
+		return false, protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "error with IBD root UTXO set")
 	}
 
 	return true, nil
 }
 
-func (flow *handleRelayInvsFlow) receivePruningPointBlock() (*externalapi.DomainBlock, error) {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "receivePruningPointBlock")
+func (flow *handleRelayInvsFlow) receiveIBDRootUTXOSetAndBlock() ([]byte, *externalapi.DomainBlock, bool, error) {
+	onEnd := logger.LogAndMeasureExecutionTime(log, "receiveIBDRootUTXOSetAndBlock")
 	defer onEnd()
 
 	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
 	if err != nil {
-		return nil, err
+		return nil, nil, false, err
 	}
 
-	ibdBlockMessage, ok := message.(*appmessage.MsgIBDBlock)
-	if !ok {
-		return nil, protocolerrors.Errorf(true, "received unexpected message type. "+
-			"expected: %s, got: %s", appmessage.CmdIBDBlock, message.Command())
+	var block *externalapi.DomainBlock
+	switch message := message.(type) {
+	case *appmessage.MsgIBDBlock:
+		block = appmessage.MsgBlockToDomainBlock(message.MsgBlock)
+	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.CmdIBDBlock, appmessage.CmdIBDRootNotFound, 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()
+	log.Debugf("Received IBD root block %s", consensushashing.BlockHash(block))
 
+	serializedUTXOSet := []byte{}
+	receivedAllChunks := false
 	receivedChunkCount := 0
-	receivedUTXOCount := 0
-	for {
+	for !receivedAllChunks {
 		message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
 		if err != nil {
-			return false, err
+			return nil, nil, 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
-
+		case *appmessage.MsgIBDRootUTXOSetChunk:
+			serializedUTXOSet = append(serializedUTXOSet, message.Chunk...)
+		case *appmessage.MsgDoneIBDRootUTXOSetChunks:
+			receivedAllChunks = true
 		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(),
-			)
+			return nil, nil, false,
+				protocolerrors.Errorf(true, "received unexpected message type. "+
+					"expected: %s or %s, got: %s",
+					appmessage.CmdIBDRootUTXOSetChunk, appmessage.CmdDoneIBDRootUTXOSetChunks, message.Command(),
+				)
+		}
+
+		receivedChunkCount++
+		if !receivedAllChunks && receivedChunkCount%ibdBatchSize == 0 {
+			log.Debugf("Received %d UTXO set chunks so far, totaling in %d bytes",
+				receivedChunkCount, len(serializedUTXOSet))
+
+			requestNextIBDRootUTXOSetChunkMessage := appmessage.NewMsgRequestNextIBDRootUTXOSetChunk()
+			err := flow.outgoingRoute.Enqueue(requestNextIBDRootUTXOSetChunkMessage)
+			if err != nil {
+				return nil, nil, false, err
+			}
 		}
 	}
+	log.Debugf("Finished receiving the UTXO set. Total bytes: %d", len(serializedUTXOSet))
+
+	return serializedUTXOSet, block, true, nil
 }
 
 func (flow *handleRelayInvsFlow) syncMissingBlockBodies(highHash *externalapi.DomainHash) error {
@@ -499,13 +434,6 @@ 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
@@ -538,17 +466,8 @@ func (flow *handleRelayInvsFlow) syncMissingBlockBodies(highHash *externalapi.Do
 				return protocolerrors.Errorf(true, "expected block %s but got %s", expectedHash, blockHash)
 			}
 
-			err = flow.banIfBlockIsHeaderOnly(block)
-			if err != nil {
-				return err
-			}
-
 			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/log.go

@@ -5,5 +5,5 @@ import (
 	"github.com/kaspanet/kaspad/util/panics"
 )
 
-var log = logger.RegisterSubSystem("PROT")
+var log, _ = logger.Get(logger.SubsystemTags.PROT)
 var spawn = panics.GoroutineWrapperFunc(log)

app/protocol/flows/blockrelay/send_virtual_selected_parent_inv.go

@@ -1,28 +0,0 @@
-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,17 +82,14 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 
 	err := context.AddToPeers(peer)
 	if err != nil {
-		if errors.Is(err, common.ErrPeerWithSameIDExists) {
+		if errors.As(err, &common.ErrPeerWithSameIDExists) {
 			return nil, protocolerrors.Wrap(false, err, "peer already exists")
 		}
 		return nil, err
 	}
 
 	if peerAddress != nil {
-		err := context.AddressManager().AddAddresses(peerAddress)
-		if err != nil {
-			return nil, err
-		}
+		context.AddressManager().AddAddresses(peerAddress)
 	}
 	return peer, nil
 }
@@ -107,7 +104,7 @@ func handleError(err error, flowName string, isStopping *uint32, errChan chan er
 		return
 	}
 
-	if protocolErr := (protocolerrors.ProtocolError{}); errors.As(err, &protocolErr) {
+	if protocolErr := &(protocolerrors.ProtocolError{}); errors.As(err, &protocolErr) {
 		log.Errorf("Handshake protocol error from %s: %s", flowName, err)
 		if atomic.AddUint32(isStopping, 1) == 1 {
 			errChan <- err

app/protocol/flows/handshake/log.go

@@ -5,5 +5,5 @@ import (
 	"github.com/kaspanet/kaspad/util/panics"
 )
 
-var log = logger.RegisterSubSystem("PROT")
+var log, _ = logger.Get(logger.SubsystemTags.PROT)
 var spawn = panics.GoroutineWrapperFunc(log)

app/protocol/flows/handshake/receiveversion.go

@@ -60,7 +60,7 @@ func (flow *receiveVersionFlow) start() (*appmessage.NetAddress, error) {
 	}
 
 	if !allowSelfConnections && flow.NetAdapter().ID().IsEqual(msgVersion.ID) {
-		return nil, protocolerrors.New(false, "connected to self")
+		return nil, protocolerrors.New(true, "connected to self")
 	}
 
 	// Disconnect and ban peers from a different network

app/protocol/flows/testing/common_test.go

@@ -1,24 +0,0 @@
-package testing
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/pkg/errors"
-)
-
-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

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

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

@@ -191,7 +191,7 @@ func (flow *handleRelayedTransactionsFlow) receiveTransactions(requestedTransact
 				continue
 			}
 
-			return protocolerrors.Errorf(true, "rejected transaction %s: %s", txID, ruleErr)
+			return protocolerrors.Errorf(true, "rejected transaction %s", txID)
 		}
 		err = flow.broadcastAcceptedTransactions([]*externalapi.DomainTransactionID{txID})
 		if err != nil {

app/protocol/log.go

@@ -5,5 +5,5 @@ import (
 	"github.com/kaspanet/kaspad/util/panics"
 )
 
-var log = logger.RegisterSubSystem("PROT")
+var log, _ = logger.Get(logger.SubsystemTags.PROT)
 var spawn = panics.GoroutineWrapperFunc(log)

app/protocol/manager.go

@@ -69,11 +69,6 @@ func (m *Manager) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler flowconte
 	m.context.SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler)
 }
 
-// SetOnPruningPointUTXOSetOverrideHandler sets the OnPruningPointUTXOSetOverride handler
-func (m *Manager) SetOnPruningPointUTXOSetOverrideHandler(onPruningPointUTXOSetOverrideHandler flowcontext.OnPruningPointUTXOSetOverrideHandler) {
-	m.context.SetOnPruningPointUTXOSetOverrideHandler(onPruningPointUTXOSetOverrideHandler)
-}
-
 // SetOnTransactionAddedToMempoolHandler sets the onTransactionAddedToMempool handler
 func (m *Manager) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler flowcontext.OnTransactionAddedToMempoolHandler) {
 	m.context.SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler)

app/protocol/peer/log.go

@@ -2,6 +2,8 @@ package peer
 
 import (
 	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/util/panics"
 )
 
-var log = logger.RegisterSubSystem("PROT")
+var log, _ = logger.Get(logger.SubsystemTags.PROT)
+var spawn = panics.GoroutineWrapperFunc(log)

app/protocol/protocol.go

@@ -1,10 +1,8 @@
 package protocol
 
 import (
-	"sync/atomic"
-
 	"github.com/kaspanet/kaspad/app/protocol/flows/rejects"
-	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
+	"sync/atomic"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/flows/addressexchange"
@@ -46,7 +44,6 @@ func (m *Manager) routerInitializer(router *routerpkg.Router, netConnection *net
 			panic(err)
 		}
 		if isBanned {
-			log.Infof("Peer %s is banned. Disconnecting...", netConnection)
 			netConnection.Disconnect()
 			return
 		}
@@ -59,20 +56,8 @@ func (m *Manager) routerInitializer(router *routerpkg.Router, netConnection *net
 
 		peer, err := handshake.HandleHandshake(m.context, netConnection, receiveVersionRoute,
 			sendVersionRoute, router.OutgoingRoute())
-
 		if err != nil {
-			// non-blocking read from channel
-			select {
-			case innerError := <-errChan:
-				if errors.Is(err, routerpkg.ErrRouteClosed) {
-					m.handleError(innerError, netConnection, router.OutgoingRoute())
-				} else {
-					log.Errorf("Peer %s sent invalid message: %s", netConnection, innerError)
-					m.handleError(err, netConnection, router.OutgoingRoute())
-				}
-			default:
-				m.handleError(err, netConnection, router.OutgoingRoute())
-			}
+			m.handleError(err, netConnection, router.OutgoingRoute())
 			return
 		}
 		defer m.context.RemoveFromPeers(peer)
@@ -88,12 +73,12 @@ func (m *Manager) routerInitializer(router *routerpkg.Router, netConnection *net
 }
 
 func (m *Manager) handleError(err error, netConnection *netadapter.NetConnection, outgoingRoute *routerpkg.Route) {
-	if protocolErr := (protocolerrors.ProtocolError{}); errors.As(err, &protocolErr) {
+	if protocolErr := &(protocolerrors.ProtocolError{}); errors.As(err, &protocolErr) {
 		if !m.context.Config().DisableBanning && protocolErr.ShouldBan {
 			log.Warnf("Banning %s (reason: %s)", netConnection, protocolErr.Cause)
 
 			err := m.context.ConnectionManager().Ban(netConnection)
-			if !errors.Is(err, connmanager.ErrCannotBanPermanent) {
+			if err != nil && !errors.Is(err, addressmanager.ErrAddressNotFound) {
 				panic(err)
 			}
 
@@ -102,7 +87,6 @@ func (m *Manager) handleError(err error, netConnection *netadapter.NetConnection
 				panic(err)
 			}
 		}
-		log.Infof("Disconnecting from %s (reason: %s)", netConnection, protocolErr.Cause)
 		netConnection.Disconnect()
 		return
 	}
@@ -149,16 +133,11 @@ 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.CmdUnexpectedPruningPoint, appmessage.CmdPruningPointUTXOSetChunk,
-			appmessage.CmdBlockHeaders, appmessage.CmdPruningPointHash, appmessage.CmdIBDBlockLocatorHighestHash,
-			appmessage.CmdIBDBlockLocatorHighestHashNotFound, appmessage.CmdDonePruningPointUTXOSetChunks},
+			appmessage.CmdDoneHeaders, appmessage.CmdIBDRootNotFound, appmessage.CmdIBDRootUTXOSetChunk,
+			appmessage.CmdBlockHeaders, appmessage.CmdIBDRootHash, appmessage.CmdIBDBlockLocatorHighestHash,
+			appmessage.CmdDoneIBDRootUTXOSetChunks},
 			isStopping, errChan, func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
 				return blockrelay.HandleRelayInvs(m.context, incomingRoute,
 					outgoingRoute, peer)
@@ -185,11 +164,11 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 			},
 		),
 
-		m.registerFlow("HandleRequestPruningPointUTXOSetAndBlock", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointUTXOSetAndBlock,
-				appmessage.CmdRequestNextPruningPointUTXOSetChunk}, isStopping, errChan,
+		m.registerFlow("HandleRequestIBDRootUTXOSetAndBlock", router,
+			[]appmessage.MessageCommand{appmessage.CmdRequestIBDRootUTXOSetAndBlock,
+				appmessage.CmdRequestNextIBDRootUTXOSetChunk}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRequestPruningPointUTXOSetAndBlock(m.context, incomingRoute, outgoingRoute)
+				return blockrelay.HandleRequestIBDRootUTXOSetAndBlock(m.context, incomingRoute, outgoingRoute)
 			},
 		),
 
@@ -200,10 +179,10 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 			},
 		),
 
-		m.registerFlow("HandlePruningPointHashRequests", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointHash}, isStopping, errChan,
+		m.registerFlow("HandleIBDRootHashRequests", router,
+			[]appmessage.MessageCommand{appmessage.CmdRequestIBDRootHash}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandlePruningPointHashRequests(m.context, incomingRoute, outgoingRoute)
+				return blockrelay.HandleIBDRootHashRequests(m.context, incomingRoute, outgoingRoute)
 			},
 		),
 

app/protocol/protocolerrors/protocolerrors.go

@@ -12,19 +12,19 @@ type ProtocolError struct {
 	Cause     error
 }
 
-func (e ProtocolError) Error() string {
+func (e *ProtocolError) Error() string {
 	return e.Cause.Error()
 }
 
 // Unwrap returns the cause of ProtocolError, to be used with `errors.Unwrap()`
-func (e ProtocolError) Unwrap() error {
+func (e *ProtocolError) Unwrap() error {
 	return e.Cause
 }
 
 // Errorf formats according to a format specifier and returns the string
 // as a ProtocolError.
 func Errorf(shouldBan bool, format string, args ...interface{}) error {
-	return ProtocolError{
+	return &ProtocolError{
 		ShouldBan: shouldBan,
 		Cause:     errors.Errorf(format, args...),
 	}
@@ -33,7 +33,7 @@ func Errorf(shouldBan bool, format string, args ...interface{}) error {
 // New returns a ProtocolError with the supplied message.
 // New also records the stack trace at the point it was called.
 func New(shouldBan bool, message string) error {
-	return ProtocolError{
+	return &ProtocolError{
 		ShouldBan: shouldBan,
 		Cause:     errors.New(message),
 	}
@@ -41,7 +41,7 @@ func New(shouldBan bool, message string) error {
 
 // Wrap wraps the given error and returns it as a ProtocolError.
 func Wrap(shouldBan bool, err error, message string) error {
-	return ProtocolError{
+	return &ProtocolError{
 		ShouldBan: shouldBan,
 		Cause:     errors.Wrap(err, message),
 	}
@@ -49,7 +49,7 @@ func Wrap(shouldBan bool, err error, message string) error {
 
 // Wrapf wraps the given error with the given format and returns it as a ProtocolError.
 func Wrapf(shouldBan bool, err error, format string, args ...interface{}) error {
-	return ProtocolError{
+	return &ProtocolError{
 		ShouldBan: shouldBan,
 		Cause:     errors.Wrapf(err, format, args...),
 	}

app/rpc/log.go

@@ -5,5 +5,5 @@ import (
 	"github.com/kaspanet/kaspad/util/panics"
 )
 
-var log = logger.RegisterSubSystem("RPCS")
+var log, _ = logger.Get(logger.SubsystemTags.RPCS)
 var spawn = panics.GoroutineWrapperFunc(log)

app/rpc/manager.go

@@ -69,31 +69,10 @@ func (m *Manager) NotifyBlockAddedToDAG(block *externalapi.DomainBlock, blockIns
 		return err
 	}
 
-	msgBlock := appmessage.DomainBlockToMsgBlock(block)
-	blockVerboseData, err := m.context.BuildBlockVerboseData(block.Header, block, false)
-	if err != nil {
-		return err
-	}
-	blockAddedNotification := appmessage.NewBlockAddedNotificationMessage(msgBlock, blockVerboseData)
+	blockAddedNotification := appmessage.NewBlockAddedNotificationMessage(appmessage.DomainBlockToMsgBlock(block))
 	return m.context.NotificationManager.NotifyBlockAdded(blockAddedNotification)
 }
 
-// NotifyPruningPointUTXOSetOverride notifies the manager whenever the UTXO index
-// resets due to pruning point change via IBD.
-func (m *Manager) NotifyPruningPointUTXOSetOverride() error {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyPruningPointUTXOSetOverride")
-	defer onEnd()
-
-	if m.context.Config.UTXOIndex {
-		err := m.notifyPruningPointUTXOSetOverride()
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
 // NotifyFinalityConflict notifies the manager that there's a finality conflict in the DAG
 func (m *Manager) NotifyFinalityConflict(violatingBlockHash string) error {
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyFinalityConflict")
@@ -116,25 +95,13 @@ func (m *Manager) notifyUTXOsChanged(blockInsertionResult *externalapi.BlockInse
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyUTXOsChanged")
 	defer onEnd()
 
-	utxoIndexChanges, err := m.context.UTXOIndex.Update(blockInsertionResult)
+	utxoIndexChanges, err := m.context.UTXOIndex.Update(blockInsertionResult.VirtualSelectedParentChainChanges)
 	if err != nil {
 		return err
 	}
 	return m.context.NotificationManager.NotifyUTXOsChanged(utxoIndexChanges)
 }
 
-func (m *Manager) notifyPruningPointUTXOSetOverride() error {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.notifyPruningPointUTXOSetOverride")
-	defer onEnd()
-
-	err := m.context.UTXOIndex.Reset()
-	if err != nil {
-		return err
-	}
-
-	return m.context.NotificationManager.NotifyPruningPointUTXOSetOverride()
-}
-
 func (m *Manager) notifyVirtualSelectedParentBlueScoreChanged() error {
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualSelectedParentBlueScoreChanged")
 	defer onEnd()

app/rpc/rpc.go

@@ -35,15 +35,9 @@ 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,
-	appmessage.CmdNotifyPruningPointUTXOSetOverrideRequestMessage:           rpchandlers.HandleNotifyPruningPointUTXOSetOverrideRequest,
-	appmessage.CmdStopNotifyingPruningPointUTXOSetOverrideRequestMessage:    rpchandlers.HandleStopNotifyingPruningPointUTXOSetOverrideRequest,
 }
 
 func (m *Manager) routerInitializer(router *router.Router, netConnection *netadapter.NetConnection) {

app/rpc/rpccontext/log.go

@@ -2,6 +2,8 @@ package rpccontext
 
 import (
 	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/util/panics"
 )
 
-var log = logger.RegisterSubSystem("RPCS")
+var log, _ = logger.Get(logger.SubsystemTags.RPCS)
+var spawn = panics.GoroutineWrapperFunc(log)

app/rpc/rpccontext/notificationmanager.go

@@ -30,9 +30,8 @@ type NotificationListener struct {
 	propagateFinalityConflictResolvedNotifications              bool
 	propagateUTXOsChangedNotifications                          bool
 	propagateVirtualSelectedParentBlueScoreChangedNotifications bool
-	propagatePruningPointUTXOSetOverrideNotifications           bool
 
-	propagateUTXOsChangedNotificationAddresses map[utxoindex.ScriptPublicKeyString]*UTXOsChangedNotificationAddress
+	propagateUTXOsChangedNotificationAddresses []*UTXOsChangedNotificationAddress
 }
 
 // NewNotificationManager creates a new NotificationManager
@@ -181,23 +180,6 @@ func (nm *NotificationManager) NotifyVirtualSelectedParentBlueScoreChanged(
 	return nil
 }
 
-// NotifyPruningPointUTXOSetOverride notifies the notification manager that the UTXO index
-// reset due to pruning point change via IBD.
-func (nm *NotificationManager) NotifyPruningPointUTXOSetOverride() error {
-	nm.RLock()
-	defer nm.RUnlock()
-
-	for router, listener := range nm.listeners {
-		if listener.propagatePruningPointUTXOSetOverrideNotifications {
-			err := router.OutgoingRoute().Enqueue(appmessage.NewPruningPointUTXOSetOverrideNotificationMessage())
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
 func newNotificationListener() *NotificationListener {
 	return &NotificationListener{
 		propagateBlockAddedNotifications:                            false,
@@ -206,7 +188,6 @@ func newNotificationListener() *NotificationListener {
 		propagateFinalityConflictResolvedNotifications:              false,
 		propagateUTXOsChangedNotifications:                          false,
 		propagateVirtualSelectedParentBlueScoreChangedNotifications: false,
-		propagatePruningPointUTXOSetOverrideNotifications:           false,
 	}
 }
 
@@ -235,70 +216,34 @@ func (nl *NotificationListener) PropagateFinalityConflictResolvedNotifications()
 }
 
 // PropagateUTXOsChangedNotifications instructs the listener to send UTXOs changed notifications
-// 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.
+// to the remote listener
 func (nl *NotificationListener) PropagateUTXOsChangedNotifications(addresses []*UTXOsChangedNotificationAddress) {
-	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)
-	}
+	nl.propagateUTXOsChangedNotifications = true
+	nl.propagateUTXOsChangedNotificationAddresses = addresses
 }
 
 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{}
-	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...)
-			}
+	for _, listenerAddress := range nl.propagateUTXOsChangedNotificationAddresses {
+		listenerScriptPublicKeyString := listenerAddress.ScriptPublicKeyString
+		if addedPairs, ok := utxoChanges.Added[listenerScriptPublicKeyString]; ok {
+			notification.Added = append(notification.Added,
+				ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(listenerAddress.Address, addedPairs)...)
 		}
-		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...)
+		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,
+					},
+				})
 			}
 		}
 	}
-
 	return notification
 }
 
@@ -307,15 +252,3 @@ func (nl *NotificationListener) convertUTXOChangesToUTXOsChangedNotification(
 func (nl *NotificationListener) PropagateVirtualSelectedParentBlueScoreChangedNotifications() {
 	nl.propagateVirtualSelectedParentBlueScoreChangedNotifications = true
 }
-
-// PropagatePruningPointUTXOSetOverrideNotifications instructs the listener to send pruning point UTXO set override notifications
-// to the remote listener.
-func (nl *NotificationListener) PropagatePruningPointUTXOSetOverrideNotifications() {
-	nl.propagatePruningPointUTXOSetOverrideNotifications = true
-}
-
-// StopPropagatingPruningPointUTXOSetOverrideNotifications instructs the listener to stop sending pruning
-// point UTXO set override notifications to the remote listener.
-func (nl *NotificationListener) StopPropagatingPruningPointUTXOSetOverrideNotifications() {
-	nl.propagatePruningPointUTXOSetOverrideNotifications = false
-}

app/rpc/rpccontext/utxos_by_addresses.go

@@ -2,9 +2,6 @@ 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"
@@ -31,43 +28,3 @@ 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

@@ -3,15 +3,12 @@ package rpccontext
 import (
 	"encoding/hex"
 	"fmt"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
+	"github.com/kaspanet/kaspad/util/difficulty"
 	"math"
 	"math/big"
 	"strconv"
 
-	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
-	"github.com/kaspanet/kaspad/infrastructure/logger"
-	"github.com/kaspanet/kaspad/util/difficulty"
-	"github.com/pkg/errors"
-
 	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 
 	"github.com/kaspanet/kaspad/domain/consensus/utils/estimatedsize"
@@ -23,36 +20,17 @@ 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/pointers"
 )
 
-// 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()
-
+// BuildBlockVerboseData builds a BlockVerboseData from the given block.
+func (ctx *Context) BuildBlockVerboseData(blockHeader externalapi.BlockHeader, includeTransactionVerboseData bool) (*appmessage.BlockVerboseData, error) {
 	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")
-	}
-
-	childrenHashes, err := ctx.Domain.Consensus().GetBlockChildren(hash)
-	if err != nil {
-		return nil, err
-	}
-
 	result := &appmessage.BlockVerboseData{
 		Hash:                 hash.String(),
 		Version:              blockHeader.Version(),
@@ -61,7 +39,6 @@ func (ctx *Context) BuildBlockVerboseData(blockHeader externalapi.BlockHeader, b
 		AcceptedIDMerkleRoot: blockHeader.AcceptedIDMerkleRoot().String(),
 		UTXOCommitment:       blockHeader.UTXOCommitment().String(),
 		ParentHashes:         hashes.ToStrings(blockHeader.ParentHashes()),
-		ChildrenHashes:       hashes.ToStrings(childrenHashes),
 		Nonce:                blockHeader.Nonce(),
 		Time:                 blockHeader.TimeInMilliseconds(),
 		Bits:                 strconv.FormatInt(int64(blockHeader.Bits()), 16),
@@ -71,11 +48,9 @@ func (ctx *Context) BuildBlockVerboseData(blockHeader externalapi.BlockHeader, b
 	}
 
 	if blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
-		if block == nil {
-			block, err = ctx.Domain.Consensus().GetBlock(hash)
-			if err != nil {
-				return nil, err
-			}
+		block, err := ctx.Domain.Consensus().GetBlock(hash)
+		if err != nil {
+			return nil, err
 		}
 
 		txIDs := make([]string, len(block.Transactions))
@@ -125,9 +100,6 @@ 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()
@@ -195,7 +167,7 @@ func (ctx *Context) buildTransactionVerboseOutputs(tx *externalapi.DomainTransac
 		passesFilter := len(filterAddrMap) == 0
 		var encodedAddr string
 		if addr != nil {
-			encodedAddr = addr.EncodeAddress()
+			encodedAddr = *pointers.String(addr.EncodeAddress())
 
 			// If the filter doesn't already pass, make it pass if
 			// the address exists in the filter.
@@ -212,7 +184,6 @@ func (ctx *Context) buildTransactionVerboseOutputs(tx *externalapi.DomainTransac
 		output.Index = uint32(i)
 		output.Value = transactionOutput.Value
 		output.ScriptPubKey = &appmessage.ScriptPubKeyResult{
-			Version: transactionOutput.ScriptPublicKey.Version,
 			Address: encodedAddr,
 			Hex:     hex.EncodeToString(transactionOutput.ScriptPublicKey.Script),
 			Type:    scriptClass.String(),

app/rpc/rpchandlers/ban.go

@@ -1,28 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"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,7 +5,6 @@ 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
@@ -29,16 +28,10 @@ func HandleGetBlock(context *rpccontext.Context, _ *router.Router, request appme
 
 	response := appmessage.NewGetBlockResponseMessage()
 
-	blockVerboseData, err := context.BuildBlockVerboseData(header, nil, getBlockRequest.IncludeTransactionVerboseData)
+	blockVerboseData, err := context.BuildBlockVerboseData(header, 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_block_dag_info.go

@@ -36,11 +36,5 @@ func HandleGetBlockDAGInfo(context *rpccontext.Context, _ *router.Router, _ appm
 	response.Difficulty = context.GetDifficultyRatio(virtualInfo.Bits, context.Config.ActiveNetParams)
 	response.PastMedianTime = virtualInfo.PastMedianTime
 
-	pruningPoint, err := context.Domain.Consensus().PruningPoint()
-	if err != nil {
-		return nil, err
-	}
-	response.PruningPointHash = pruningPoint.String()
-
 	return response, nil
 }

app/rpc/rpchandlers/get_blocks.go

@@ -3,104 +3,18 @@ package rpchandlers
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
 const (
 	// maxBlocksInGetBlocksResponse is the max amount of blocks that are
 	// allowed in a GetBlocksResult.
-	maxBlocksInGetBlocksResponse = 1000
+	maxBlocksInGetBlocksResponse = 100
 )
 
 // HandleGetBlocks handles the respectively named RPC command
 func HandleGetBlocks(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	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
-		}
-
-		blockInfo, err := context.Domain.Consensus().GetBlockInfo(lowHash)
-		if err != nil {
-			return nil, err
-		}
-
-		if !blockInfo.Exists {
-			return &appmessage.GetBlocksResponseMessage{
-				Error: appmessage.RPCErrorf("Could not find lowHash %s", getBlocksRequest.LowHash),
-			}, 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
-		}
-	}
+	response := &appmessage.GetBlocksResponseMessage{}
+	response.Error = appmessage.RPCErrorf("not implemented")
 	return response, nil
 }

app/rpc/rpchandlers/get_blocks_test.go

@@ -1,144 +0,0 @@
-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_info.go

@@ -1,13 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// 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/log.go

@@ -5,5 +5,5 @@ import (
 	"github.com/kaspanet/kaspad/util/panics"
 )
 
-var log = logger.RegisterSubSystem("RPCS")
+var log, _ = logger.Get(logger.SubsystemTags.RPCS)
 var spawn = panics.GoroutineWrapperFunc(log)

app/rpc/rpchandlers/notify_pruning_point_utxo_set_overrides.go

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

app/rpc/rpchandlers/notify_utxos_changed.go

@@ -3,7 +3,10 @@ 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
@@ -15,11 +18,26 @@ func HandleNotifyUTXOsChanged(context *rpccontext.Context, router *router.Router
 	}
 
 	notifyUTXOsChangedRequest := request.(*appmessage.NotifyUTXOsChangedRequestMessage)
-	addresses, err := context.ConvertAddressStringsToUTXOsChangedNotificationAddresses(notifyUTXOsChangedRequest.Addresses)
-	if err != nil {
-		errorMessage := appmessage.NewNotifyUTXOsChangedResponseMessage()
-		errorMessage.Error = appmessage.RPCErrorf("Parsing error: %s", err)
-		return errorMessage, nil
+
+	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,
+		}
 	}
 
 	listener, err := context.NotificationManager.Listener(router)

app/rpc/rpchandlers/stop_notifying_pruning_point_utxo_set_overrides.go

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

app/rpc/rpchandlers/stop_notifying_utxos_changed.go

@@ -1,33 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// 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

@@ -2,7 +2,6 @@ package rpchandlers
 
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
@@ -26,11 +25,9 @@ func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request ap
 
 	err := context.ProtocolManager.AddBlock(domainBlock)
 	if err != nil {
-		isProtocolOrRuleError := errors.As(err, &ruleerrors.RuleError{}) || errors.As(err, &protocolerrors.ProtocolError{})
-		if !isProtocolOrRuleError {
+		if !errors.As(err, &ruleerrors.RuleError{}) {
 			return nil, err
 		}
-
 		return &appmessage.SubmitBlockResponseMessage{
 			Error:        appmessage.RPCErrorf("Block rejected. Reason: %s", err),
 			RejectReason: appmessage.RejectReasonBlockInvalid,

app/rpc/rpchandlers/unban.go

@@ -1,27 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"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

@@ -19,9 +19,4 @@ go vet -composites=false $FLAGS ./...
 
 go build $FLAGS -o kaspad .
 
-if [ -n "${NO_PARALLEL}" ]
-then
-  go test -parallel=1 $FLAGS ./...
-else
-  go test $FLAGS ./...
-fi
+go test $FLAGS ./...

changelog.txt

@@ -1,35 +0,0 @@
-
-Kaspad v0.9.1 - 2021-03-14
-===========================
-* Testnet network reset
-
-Kaspad v0.9.0 - 2021-03-04
-===========================
-
-* Merge big subdags in pick virtual parents (#1574)
-* Write in the reject message the tx rejection reason (#1573)
-* Add nil checks for protowire (#1570)
-* Increase getBlocks limit to 1000 (#1572)
-* Return RPC error if getBlock's lowHash doesn't exist (#1569)
-* Add default dns-seeder to testnet (#1568)
-* Fix utxoindex deserialization (#1566)
-* Add pruning point hash to GetBlockDagInfo response (#1565)
-* Use EmitUnpopulated so that kaspactl prints all fields, even the default ones (#1561)
-* Stop logging an error whenever an RPC/P2P connection is canceled  (#1562)
-* Cleanup the logger and make it asynchronous (#1524)
-* Close all iterators (#1542)
-* Add childrenHashes to GetBlock/s RPC commands (#1560)
-* Add ScriptPublicKey.Version to RPC (#1559)
-* Fix the target block rate to create less bursty mining (#1554)
-
-Kaspad v0.8.10 - 2021-02-25
-===========================
-
-* Fix bug where invalid mempool transactions were not removed (#1551)
-* Add RPC reconnection to the miner (#1552)
-* Remove virtual diff parents - only selectedTip is virtualDiffParent now (#1550)
-* Fix UTXO index (#1548)
-* Prevent fast failing (#1545)
-* Increase the sleep time in kaspaminer when the node is not synced (#1544)
-* Disallow header only blocks on RPC, relay and when requesting IBD full blocks (#1537)
-* Make templateManager hold a DomainBlock and isSynced bool instead of a GetBlockTemplateResponseMessage (#1538)

cmd/kaspactl/README.md

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

cmd/kaspactl/command_parser.go

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

@@ -1,91 +0,0 @@
-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,11 +12,9 @@ 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 `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
+	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"`
 	config.NetworkFlags
 }
 
@@ -25,29 +23,21 @@ func parseConfig() (*configFlags, error) {
 		RPCServer: defaultRPCServer,
 		Timeout:   defaultTimeout,
 	}
-	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()
+	parser := flags.NewParser(cfg, flags.PrintErrors|flags.HelpFlag)
+	args, 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
 	}
 
-	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")
+	if len(args) != 1 {
+		return nil, errors.New("the last parameter must be the request in JSON format")
 	}
+	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.16-alpine AS build
+FROM golang:1.14-alpine AS build
 
 RUN mkdir -p /go/src/github.com/kaspanet/kaspad
 

cmd/kaspactl/main.go

@@ -2,15 +2,9 @@ package main
 
 import (
 	"fmt"
+	"github.com/kaspanet/kaspad/infrastructure/network/rpcclient/grpcclient"
 	"os"
 	"time"
-
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/server/grpcserver/protowire"
-
-	"github.com/pkg/errors"
-	"google.golang.org/protobuf/encoding/protojson"
-
-	"github.com/kaspanet/kaspad/infrastructure/network/rpcclient/grpcclient"
 )
 
 func main() {
@@ -18,10 +12,6 @@ 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 {
@@ -33,70 +23,28 @@ func main() {
 	}
 	defer client.Disconnect()
 
-	responseChan := make(chan string)
+	var responseString string
+	done := make(chan struct{})
 
-	if cfg.RequestJSON != "" {
-		go postJSON(cfg, client, responseChan)
-	} else {
-		go postCommand(cfg, client, responseChan)
-	}
+	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{}{}
+	}()
 
 	timeout := time.Duration(cfg.Timeout) * time.Second
 	select {
-	case responseString := <-responseChan:
-		prettyResponseString := prettifyResponse(responseString)
-		fmt.Println(prettyResponseString)
+	case <-done:
+		fmt.Println(responseString)
 	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.MarshalOptions{EmitUnpopulated: true}.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 = "    "
-	marshalOptions.EmitUnpopulated = true
-	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

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

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