Pruning fixes (#1243)

* Pruning related fixes

* Rename setBlockStatus->setBlockStatusAfterBlockValidation

* Rename StatusValid->StatusUTXOValid

* Add comment

* Fix typo

* Rename hasValidatedOnlyHeader->hasValidatedHeader

* Rename checkBlockBodiesExist->checkParentBlockBodiesExist

* Add comments and logs

* Adding logs

* Add logs and assert

* Add comment

* Fix typo

* Fix log

.codecov.yml

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

.github/workflows/SetPageFileSize.ps1

@@ -1,196 +0,0 @@
-<#
-# MIT License (MIT) Copyright (c) 2020 Maxim Lobanov and contributors
-# Source: https://github.com/al-cheb/configure-pagefile-action/blob/master/scripts/SetPageFileSize.ps1
-.SYNOPSIS
-  Configure Pagefile on Windows machine
-.NOTES
-  Author:         Aleksandr Chebotov
-
-.EXAMPLE
-  SetPageFileSize.ps1 -MinimumSize 4GB -MaximumSize 8GB -DiskRoot "D:"
-#>
-
-param(
-    [System.UInt64] $MinimumSize = 8gb ,
-    [System.UInt64] $MaximumSize = 8gb ,
-    [System.String] $DiskRoot = "D:"
-)
-
-# https://referencesource.microsoft.com/#System.IdentityModel/System/IdentityModel/NativeMethods.cs,619688d876febbe1
-# https://www.geoffchappell.com/studies/windows/km/ntoskrnl/api/mm/modwrite/create.htm
-# https://referencesource.microsoft.com/#mscorlib/microsoft/win32/safehandles/safefilehandle.cs,9b08210f3be75520
-# https://referencesource.microsoft.com/#mscorlib/system/security/principal/tokenaccesslevels.cs,6eda91f498a38586
-# https://www.autoitscript.com/forum/topic/117993-api-ntcreatepagingfile/
-
-$source = @'
-using System;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Security.Principal;
-using System.Text;
-using Microsoft.Win32;
-using Microsoft.Win32.SafeHandles;
-
-namespace Util
-{
-    class NativeMethods
-    {
-        [StructLayout(LayoutKind.Sequential)]
-        internal struct LUID
-        {
-            internal uint LowPart;
-            internal uint HighPart;
-        }
-    
-        [StructLayout(LayoutKind.Sequential)]
-        internal struct LUID_AND_ATTRIBUTES
-        {
-            internal LUID Luid;
-            internal uint Attributes;
-        }
-    
-        [StructLayout(LayoutKind.Sequential)]
-        internal struct TOKEN_PRIVILEGE
-        {
-            internal uint PrivilegeCount;
-            internal LUID_AND_ATTRIBUTES Privilege;
-    
-            internal static readonly uint Size = (uint)Marshal.SizeOf(typeof(TOKEN_PRIVILEGE));
-        }
-
-        [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
-        internal struct UNICODE_STRING
-        {
-            internal UInt16 length;
-            internal UInt16 maximumLength;
-            internal string buffer;
-        }
-
-        [DllImport("kernel32.dll", SetLastError=true)]
-        internal static extern IntPtr LocalFree(IntPtr handle);
-
-        [DllImport("advapi32.dll", ExactSpelling = true, CharSet = CharSet.Unicode, SetLastError = true, PreserveSig = false)]
-        internal static extern bool LookupPrivilegeValueW(
-            [In] string lpSystemName,
-            [In] string lpName,
-            [Out] out LUID luid
-        );
-
-        [DllImport("advapi32.dll", SetLastError = true, PreserveSig = false)]
-        internal static extern bool AdjustTokenPrivileges(
-            [In] SafeCloseHandle tokenHandle,
-            [In] bool disableAllPrivileges,
-            [In] ref TOKEN_PRIVILEGE newState,
-            [In] uint bufferLength,
-            [Out] out TOKEN_PRIVILEGE previousState,
-            [Out] out uint returnLength
-        );
-
-        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true, PreserveSig = false)]
-        internal static extern bool OpenProcessToken(
-            [In] IntPtr processToken,
-            [In] int desiredAccess,
-            [Out] out SafeCloseHandle tokenHandle
-        );
-
-        [DllImport("ntdll.dll", CharSet = CharSet.Unicode, SetLastError = true, CallingConvention = CallingConvention.StdCall)]
-        internal static extern Int32 NtCreatePagingFile(
-            [In] ref UNICODE_STRING pageFileName, 
-            [In] ref Int64 minimumSize, 
-            [In] ref Int64 maximumSize, 
-            [In] UInt32 flags
-        );
-
-        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
-        internal static extern uint QueryDosDeviceW(
-            string lpDeviceName,
-            StringBuilder lpTargetPath,
-            int ucchMax
-        );
-    }
-
-    public sealed class SafeCloseHandle: SafeHandleZeroOrMinusOneIsInvalid 
-    {
-        [DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true)]
-        internal extern static bool CloseHandle(IntPtr handle);
-
-        private SafeCloseHandle() : base(true)
-        {
-        }
- 
-        public SafeCloseHandle(IntPtr preexistingHandle, bool ownsHandle) : base(ownsHandle) 
-        {
-            SetHandle(preexistingHandle);
-        }
-
-        override protected bool ReleaseHandle()
-        {
-            return CloseHandle(handle);
-        }
-    }
-
-    public class PageFile
-    {
-        public static void SetPageFileSize(long minimumValue, long maximumValue, string lpDeviceName)
-        {
-            SetPageFilePrivilege();
-            StringBuilder lpTargetPath = new StringBuilder(260);
-
-            UInt32 resultQueryDosDevice = NativeMethods.QueryDosDeviceW(lpDeviceName, lpTargetPath, lpTargetPath.Capacity);
-            if (resultQueryDosDevice == 0)
-            {
-                throw new Win32Exception(Marshal.GetLastWin32Error());
-            }
-
-            string pageFilePath = lpTargetPath.ToString() + "\\pagefile.sys";
-
-            NativeMethods.UNICODE_STRING pageFileName = new NativeMethods.UNICODE_STRING
-            {
-                length = (ushort)(pageFilePath.Length * 2),
-                maximumLength = (ushort)(2 * (pageFilePath.Length + 1)),
-                buffer = pageFilePath
-            };
-
-            Int32 resultNtCreatePagingFile = NativeMethods.NtCreatePagingFile(ref pageFileName, ref minimumValue, ref maximumValue, 0);
-            if (resultNtCreatePagingFile != 0)
-            {
-                throw new Win32Exception(Marshal.GetLastWin32Error());
-            }
-
-            Console.WriteLine("PageFile: {0} / {1} bytes for {2}", minimumValue, maximumValue, pageFilePath);
-        }
-
-        static void SetPageFilePrivilege()
-        {
-            const int SE_PRIVILEGE_ENABLED = 0x00000002;
-            const int AdjustPrivileges = 0x00000020;
-            const int Query = 0x00000008;
-
-            NativeMethods.LUID luid;
-            NativeMethods.LookupPrivilegeValueW(null, "SeCreatePagefilePrivilege", out luid);
-
-            SafeCloseHandle hToken;
-            NativeMethods.OpenProcessToken(
-                Process.GetCurrentProcess().Handle,
-                AdjustPrivileges | Query,
-                out hToken
-            );
-
-            NativeMethods.TOKEN_PRIVILEGE previousState;
-            NativeMethods.TOKEN_PRIVILEGE newState;
-            uint previousSize = 0;
-            newState.PrivilegeCount = 1;
-            newState.Privilege.Luid = luid;
-            newState.Privilege.Attributes = SE_PRIVILEGE_ENABLED;
-
-            NativeMethods.AdjustTokenPrivileges(hToken, false, ref newState, NativeMethods.TOKEN_PRIVILEGE.Size, out previousState, out previousSize);
-        }
-    }
-}
-'@
-
-Add-Type -TypeDefinition $source
-
-# Set SetPageFileSize
-[Util.PageFile]::SetPageFileSize($minimumSize, $maximumSize, $diskRoot)

.github/workflows/go.yml

@@ -1,70 +0,0 @@
-name: Go
-
-on:
-  push:
-  pull_request:
-    # edtited - "title, body, or the base branch of the PR is modified"
-    # synchronize - "commit(s) pushed to the pull request"
-    types: [opened, synchronize, edited, reopened]
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-16.04, macos-10.15 ]
-    name: Testing on on ${{ 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.15
-
-
-      # Source: https://github.com/actions/cache/blob/main/examples.md#go---modules
-      - name: Go Cache
-        uses: actions/cache@v2
-        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-
-      - name: Test
-        shell: bash
-        run: ./build_and_test.sh
-
-  coverage:
-    runs-on: ubuntu-20.04
-    name: Produce code coverage
-    steps:
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
-
-      - name: Set up Go 1.x
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.15
-
-      - name: Create coverage file
-        # 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)

.gitignore

@@ -13,21 +13,6 @@ kaspad.db
 *.o
 *.a
 *.so
-*.dylib
-
-# Test binary, built with `go test -c`
-*.test
-
-# Real binaries, build with `go build .`
-kaspad
-cmd/gencerts/gencerts
-cmd/kaspactl/kaspactl
-cmd/kasminer/kaspaminer
-*.exe
-*.exe~
-
-# Output of the go coverage tool
-*.out
 
 # Folders
 _obj
@@ -46,7 +31,8 @@ _cgo_export.*
 
 _testmain.go
 
-
+*.exe
+ 
 # IDE
 .idea
 .vscode

CONTRIBUTING.md

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

README.md

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

app/appmessage/common.go

@@ -5,9 +5,19 @@
 package appmessage
 
 import (
+	"fmt"
+	"io"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/util/binaryserializer"
+	"github.com/kaspanet/kaspad/util/mstime"
 	"github.com/pkg/errors"
 )
 
+// MaxVarIntPayload is the maximum payload size for a variable length integer.
+const MaxVarIntPayload = 9
+
 // MaxInvPerMsg is the maximum number of inventory vectors that can be in any type of kaspa inv message.
 const MaxInvPerMsg = 1 << 17
 
@@ -18,3 +28,333 @@ var errNonCanonicalVarInt = "non-canonical varint %x - discriminant %x must " +
 
 // errNoEncodingForType signifies that there's no encoding for the given type.
 var errNoEncodingForType = errors.New("there's no encoding for this type")
+
+// int64Time represents a unix timestamp with milliseconds precision encoded with
+// an int64. It is used as a way to signal the readElement function how to decode
+// a timestamp into a Go mstime.Time since it is otherwise ambiguous.
+type int64Time mstime.Time
+
+// ReadElement reads the next sequence of bytes from r using little endian
+// depending on the concrete type of element pointed to.
+func ReadElement(r io.Reader, element interface{}) error {
+	// Attempt to read the element based on the concrete type via fast
+	// type assertions first.
+	switch e := element.(type) {
+	case *int32:
+		rv, err := binaryserializer.Uint32(r)
+		if err != nil {
+			return err
+		}
+		*e = int32(rv)
+		return nil
+
+	case *uint32:
+		rv, err := binaryserializer.Uint32(r)
+		if err != nil {
+			return err
+		}
+		*e = rv
+		return nil
+
+	case *int64:
+		rv, err := binaryserializer.Uint64(r)
+		if err != nil {
+			return err
+		}
+		*e = int64(rv)
+		return nil
+
+	case *uint64:
+		rv, err := binaryserializer.Uint64(r)
+		if err != nil {
+			return err
+		}
+		*e = rv
+		return nil
+
+	case *uint8:
+		rv, err := binaryserializer.Uint8(r)
+		if err != nil {
+			return err
+		}
+		*e = rv
+		return nil
+
+	case *bool:
+		rv, err := binaryserializer.Uint8(r)
+		if err != nil {
+			return err
+		}
+		if rv == 0x00 {
+			*e = false
+		} else {
+			*e = true
+		}
+		return nil
+
+	// Unix timestamp encoded as an int64.
+	case *int64Time:
+		rv, err := binaryserializer.Uint64(r)
+		if err != nil {
+			return err
+		}
+		*e = int64Time(mstime.UnixMilliseconds(int64(rv)))
+		return nil
+
+	// Message header checksum.
+	case *[4]byte:
+		_, err := io.ReadFull(r, e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// Message header command.
+	case *MessageCommand:
+		rv, err := binaryserializer.Uint32(r)
+		if err != nil {
+			return err
+		}
+		*e = MessageCommand(rv)
+		return nil
+
+	// IP address.
+	case *[16]byte:
+		_, err := io.ReadFull(r, e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case *externalapi.DomainHash:
+		_, err := io.ReadFull(r, e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case *id.ID:
+		return e.Deserialize(r)
+
+	case *externalapi.DomainSubnetworkID:
+		_, err := io.ReadFull(r, e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case *ServiceFlag:
+		rv, err := binaryserializer.Uint64(r)
+		if err != nil {
+			return err
+		}
+		*e = ServiceFlag(rv)
+		return nil
+
+	case *KaspaNet:
+		rv, err := binaryserializer.Uint32(r)
+		if err != nil {
+			return err
+		}
+		*e = KaspaNet(rv)
+		return nil
+	}
+
+	return errors.Wrapf(errNoEncodingForType, "couldn't find a way to read type %T", element)
+}
+
+// readElements reads multiple items from r. It is equivalent to multiple
+// calls to readElement.
+func readElements(r io.Reader, elements ...interface{}) error {
+	for _, element := range elements {
+		err := ReadElement(r, element)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// WriteElement writes the little endian representation of element to w.
+func WriteElement(w io.Writer, element interface{}) error {
+	// Attempt to write the element based on the concrete type via fast
+	// type assertions first.
+	switch e := element.(type) {
+	case int32:
+		err := binaryserializer.PutUint32(w, uint32(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case uint32:
+		err := binaryserializer.PutUint32(w, e)
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case int64:
+		err := binaryserializer.PutUint64(w, uint64(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case uint64:
+		err := binaryserializer.PutUint64(w, e)
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case uint8:
+		err := binaryserializer.PutUint8(w, e)
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case bool:
+		var err error
+		if e {
+			err = binaryserializer.PutUint8(w, 0x01)
+		} else {
+			err = binaryserializer.PutUint8(w, 0x00)
+		}
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// Message header checksum.
+	case [4]byte:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// Message header command.
+	case MessageCommand:
+		err := binaryserializer.PutUint32(w, uint32(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// IP address.
+	case [16]byte:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case *externalapi.DomainHash:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case *id.ID:
+		return e.Serialize(w)
+
+	case *externalapi.DomainSubnetworkID:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case ServiceFlag:
+		err := binaryserializer.PutUint64(w, uint64(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case KaspaNet:
+		err := binaryserializer.PutUint32(w, uint32(e))
+		if err != nil {
+			return err
+		}
+		return nil
+	}
+
+	return errors.Wrapf(errNoEncodingForType, "couldn't find a way to write type %T", element)
+}
+
+// writeElements writes multiple items to w. It is equivalent to multiple
+// calls to writeElement.
+func writeElements(w io.Writer, elements ...interface{}) error {
+	for _, element := range elements {
+		err := WriteElement(w, element)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ReadVarInt reads a variable length integer from r and returns it as a uint64.
+func ReadVarInt(r io.Reader) (uint64, error) {
+	discriminant, err := binaryserializer.Uint8(r)
+	if err != nil {
+		return 0, err
+	}
+
+	var rv uint64
+	switch discriminant {
+	case 0xff:
+		sv, err := binaryserializer.Uint64(r)
+		if err != nil {
+			return 0, err
+		}
+		rv = sv
+
+		// The encoding is not canonical if the value could have been
+		// encoded using fewer bytes.
+		min := uint64(0x100000000)
+		if rv < min {
+			return 0, messageError("readVarInt", fmt.Sprintf(
+				errNonCanonicalVarInt, rv, discriminant, min))
+		}
+
+	case 0xfe:
+		sv, err := binaryserializer.Uint32(r)
+		if err != nil {
+			return 0, err
+		}
+		rv = uint64(sv)
+
+		// The encoding is not canonical if the value could have been
+		// encoded using fewer bytes.
+		min := uint64(0x10000)
+		if rv < min {
+			return 0, messageError("readVarInt", fmt.Sprintf(
+				errNonCanonicalVarInt, rv, discriminant, min))
+		}
+
+	case 0xfd:
+		sv, err := binaryserializer.Uint16(r)
+		if err != nil {
+			return 0, err
+		}
+		rv = uint64(sv)
+
+		// The encoding is not canonical if the value could have been
+		// encoded using fewer bytes.
+		min := uint64(0xfd)
+		if rv < min {
+			return 0, messageError("readVarInt", fmt.Sprintf(
+				errNonCanonicalVarInt, rv, discriminant, min))
+		}
+
+	default:
+		rv = uint64(discriminant)
+	}
+
+	return rv, nil
+}

app/appmessage/common_test.go

@@ -1,44 +1,234 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
 package appmessage
 
-import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+import (
+	"bytes"
+	"io"
+	"reflect"
+	"testing"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/pkg/errors"
+
+	"github.com/davecgh/go-spew/spew"
+)
 
 // mainnetGenesisHash is the hash of the first block in the block DAG for the
 // main network (genesis block).
-var mainnetGenesisHash = externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
+var mainnetGenesisHash = &externalapi.DomainHash{
 	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25,
 	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
 	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
 	0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
-})
+}
 
 // simnetGenesisHash is the hash of the first block in the block DAG for the
 // simulation test network.
-var simnetGenesisHash = externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
+var simnetGenesisHash = &externalapi.DomainHash{
 	0x9d, 0x89, 0xb0, 0x6e, 0xb3, 0x47, 0xb5, 0x6e,
 	0xcd, 0x6c, 0x63, 0x99, 0x45, 0x91, 0xd5, 0xce,
 	0x9b, 0x43, 0x05, 0xc1, 0xa5, 0x5e, 0x2a, 0xda,
 	0x90, 0x4c, 0xf0, 0x6c, 0x4d, 0x5f, 0xd3, 0x62,
-})
+}
 
 // mainnetGenesisMerkleRoot is the hash of the first transaction in the genesis
 // block for the main network.
-var mainnetGenesisMerkleRoot = externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
+var mainnetGenesisMerkleRoot = &externalapi.DomainHash{
 	0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a,
 	0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 	0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 	0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
-})
+}
 
-var exampleAcceptedIDMerkleRoot = externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
+var exampleAcceptedIDMerkleRoot = &externalapi.DomainHash{
 	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-})
+}
 
-var exampleUTXOCommitment = externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
+var exampleUTXOCommitment = &externalapi.DomainHash{
 	0x10, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-})
+}
+
+// TestElementEncoding tests appmessage encode and decode for various element types. This
+// is mainly to test the "fast" paths in readElement and writeElement which use
+// type assertions to avoid reflection when possible.
+func TestElementEncoding(t *testing.T) {
+	tests := []struct {
+		in  interface{} // Value to encode
+		buf []byte      // Encoded value
+	}{
+		{int32(1), []byte{0x01, 0x00, 0x00, 0x00}},
+		{uint32(256), []byte{0x00, 0x01, 0x00, 0x00}},
+		{
+			int64(65536),
+			[]byte{0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
+		},
+		{
+			uint64(4294967296),
+			[]byte{0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00},
+		},
+		{
+			true,
+			[]byte{0x01},
+		},
+		{
+			false,
+			[]byte{0x00},
+		},
+		{
+			[4]byte{0x01, 0x02, 0x03, 0x04},
+			[]byte{0x01, 0x02, 0x03, 0x04},
+		},
+		{
+			MessageCommand(0x10),
+			[]byte{
+				0x10, 0x00, 0x00, 0x00,
+			},
+		},
+		{
+			[16]byte{
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+			},
+			[]byte{
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+			},
+		},
+		{
+			(*externalapi.DomainHash)(&[externalapi.DomainHashSize]byte{
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+				0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+			}),
+			[]byte{
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+				0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+			},
+		},
+		{
+			ServiceFlag(SFNodeNetwork),
+			[]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+		},
+		{
+			KaspaNet(Mainnet),
+			[]byte{0x1d, 0xf7, 0xdc, 0x3d},
+		},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Write to appmessage format.
+		var buf bytes.Buffer
+		err := WriteElement(&buf, test.in)
+		if err != nil {
+			t.Errorf("writeElement #%d error %v", i, err)
+			continue
+		}
+		if !bytes.Equal(buf.Bytes(), test.buf) {
+			t.Errorf("writeElement #%d\n got: %s want: %s", i,
+				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
+			continue
+		}
+
+		// Read from appmessage format.
+		rbuf := bytes.NewReader(test.buf)
+		val := test.in
+		if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
+			val = reflect.New(reflect.TypeOf(test.in)).Interface()
+		}
+		err = ReadElement(rbuf, val)
+		if err != nil {
+			t.Errorf("readElement #%d error %v", i, err)
+			continue
+		}
+		ival := val
+		if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
+			ival = reflect.Indirect(reflect.ValueOf(val)).Interface()
+		}
+		if !reflect.DeepEqual(ival, test.in) {
+			t.Errorf("readElement #%d\n got: %s want: %s", i,
+				spew.Sdump(ival), spew.Sdump(test.in))
+			continue
+		}
+	}
+}
+
+// TestElementEncodingErrors performs negative tests against appmessage encode and decode
+// of various element types to confirm error paths work correctly.
+func TestElementEncodingErrors(t *testing.T) {
+	type writeElementReflect int32
+
+	tests := []struct {
+		in       interface{} // Value to encode
+		max      int         // Max size of fixed buffer to induce errors
+		writeErr error       // Expected write error
+		readErr  error       // Expected read error
+	}{
+		{int32(1), 0, io.ErrShortWrite, io.EOF},
+		{uint32(256), 0, io.ErrShortWrite, io.EOF},
+		{int64(65536), 0, io.ErrShortWrite, io.EOF},
+		{true, 0, io.ErrShortWrite, io.EOF},
+		{[4]byte{0x01, 0x02, 0x03, 0x04}, 0, io.ErrShortWrite, io.EOF},
+		{
+			MessageCommand(10),
+			0, io.ErrShortWrite, io.EOF,
+		},
+		{
+			[16]byte{
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+			},
+			0, io.ErrShortWrite, io.EOF,
+		},
+		{
+			(*externalapi.DomainHash)(&[externalapi.DomainHashSize]byte{
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+				0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+			}),
+			0, io.ErrShortWrite, io.EOF,
+		},
+		{ServiceFlag(SFNodeNetwork), 0, io.ErrShortWrite, io.EOF},
+		{KaspaNet(Mainnet), 0, io.ErrShortWrite, io.EOF},
+		// Type with no supported encoding.
+		{writeElementReflect(0), 0, errNoEncodingForType, errNoEncodingForType},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		w := newFixedWriter(test.max)
+		err := WriteElement(w, test.in)
+		if !errors.Is(err, test.writeErr) {
+			t.Errorf("writeElement #%d wrong error got: %v, want: %v",
+				i, err, test.writeErr)
+			continue
+		}
+
+		// Decode from appmessage format.
+		r := newFixedReader(test.max, nil)
+		val := test.in
+		if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
+			val = reflect.New(reflect.TypeOf(test.in)).Interface()
+		}
+		err = ReadElement(r, val)
+		if !errors.Is(err, test.readErr) {
+			t.Errorf("readElement #%d wrong error got: %v, want: %v",
+				i, err, test.readErr)
+			continue
+		}
+	}
+}

app/appmessage/domainconverters.go

@@ -1,13 +1,7 @@
 package appmessage
 
 import (
-	"encoding/hex"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/blockheader"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
-
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
 	"github.com/kaspanet/kaspad/util/mstime"
 )
 
@@ -23,17 +17,17 @@ func DomainBlockToMsgBlock(domainBlock *externalapi.DomainBlock) *MsgBlock {
 	}
 }
 
-// DomainBlockHeaderToBlockHeader converts an externalapi.BlockHeader to MsgBlockHeader
-func DomainBlockHeaderToBlockHeader(domainBlockHeader externalapi.BlockHeader) *MsgBlockHeader {
+// DomainBlockHeaderToBlockHeader converts an externalapi.DomainBlockHeader to MsgBlockHeader
+func DomainBlockHeaderToBlockHeader(domainBlockHeader *externalapi.DomainBlockHeader) *MsgBlockHeader {
 	return &MsgBlockHeader{
-		Version:              domainBlockHeader.Version(),
-		ParentHashes:         domainBlockHeader.ParentHashes(),
-		HashMerkleRoot:       domainBlockHeader.HashMerkleRoot(),
-		AcceptedIDMerkleRoot: domainBlockHeader.AcceptedIDMerkleRoot(),
-		UTXOCommitment:       domainBlockHeader.UTXOCommitment(),
-		Timestamp:            mstime.UnixMilliseconds(domainBlockHeader.TimeInMilliseconds()),
-		Bits:                 domainBlockHeader.Bits(),
-		Nonce:                domainBlockHeader.Nonce(),
+		Version:              domainBlockHeader.Version,
+		ParentHashes:         domainBlockHeader.ParentHashes,
+		HashMerkleRoot:       &domainBlockHeader.HashMerkleRoot,
+		AcceptedIDMerkleRoot: &domainBlockHeader.AcceptedIDMerkleRoot,
+		UTXOCommitment:       &domainBlockHeader.UTXOCommitment,
+		Timestamp:            mstime.UnixMilliseconds(domainBlockHeader.TimeInMilliseconds),
+		Bits:                 domainBlockHeader.Bits,
+		Nonce:                domainBlockHeader.Nonce,
 	}
 }
 
@@ -50,18 +44,18 @@ func MsgBlockToDomainBlock(msgBlock *MsgBlock) *externalapi.DomainBlock {
 	}
 }
 
-// BlockHeaderToDomainBlockHeader converts a MsgBlockHeader to externalapi.BlockHeader
-func BlockHeaderToDomainBlockHeader(blockHeader *MsgBlockHeader) externalapi.BlockHeader {
-	return blockheader.NewImmutableBlockHeader(
-		blockHeader.Version,
-		blockHeader.ParentHashes,
-		blockHeader.HashMerkleRoot,
-		blockHeader.AcceptedIDMerkleRoot,
-		blockHeader.UTXOCommitment,
-		blockHeader.Timestamp.UnixMilliseconds(),
-		blockHeader.Bits,
-		blockHeader.Nonce,
-	)
+// BlockHeaderToDomainBlockHeader converts a MsgBlockHeader to externalapi.DomainBlockHeader
+func BlockHeaderToDomainBlockHeader(blockHeader *MsgBlockHeader) *externalapi.DomainBlockHeader {
+	return &externalapi.DomainBlockHeader{
+		Version:              blockHeader.Version,
+		ParentHashes:         blockHeader.ParentHashes,
+		HashMerkleRoot:       *blockHeader.HashMerkleRoot,
+		AcceptedIDMerkleRoot: *blockHeader.AcceptedIDMerkleRoot,
+		UTXOCommitment:       *blockHeader.UTXOCommitment,
+		TimeInMilliseconds:   blockHeader.Timestamp.UnixMilliseconds(),
+		Bits:                 blockHeader.Bits,
+		Nonce:                blockHeader.Nonce,
+	}
 }
 
 // DomainTransactionToMsgTx converts an externalapi.DomainTransaction into an MsgTx
@@ -159,159 +153,3 @@ func outpointToDomainOutpoint(outpoint *Outpoint) *externalapi.DomainOutpoint {
 		Index:         outpoint.Index,
 	}
 }
-
-// RPCTransactionToDomainTransaction converts RPCTransactions to DomainTransactions
-func RPCTransactionToDomainTransaction(rpcTransaction *RPCTransaction) (*externalapi.DomainTransaction, error) {
-	inputs := make([]*externalapi.DomainTransactionInput, len(rpcTransaction.Inputs))
-	for i, input := range rpcTransaction.Inputs {
-		transactionIDBytes, err := hex.DecodeString(input.PreviousOutpoint.TransactionID)
-		if err != nil {
-			return nil, err
-		}
-		transactionID, err := transactionid.FromBytes(transactionIDBytes)
-		if err != nil {
-			return nil, err
-		}
-		previousOutpoint := &externalapi.DomainOutpoint{
-			TransactionID: *transactionID,
-			Index:         input.PreviousOutpoint.Index,
-		}
-		signatureScript, err := hex.DecodeString(input.SignatureScript)
-		if err != nil {
-			return nil, err
-		}
-		inputs[i] = &externalapi.DomainTransactionInput{
-			PreviousOutpoint: *previousOutpoint,
-			SignatureScript:  signatureScript,
-			Sequence:         input.Sequence,
-		}
-	}
-	outputs := make([]*externalapi.DomainTransactionOutput, len(rpcTransaction.Outputs))
-	for i, output := range rpcTransaction.Outputs {
-		scriptPublicKey, err := hex.DecodeString(output.ScriptPublicKey.Script)
-		if err != nil {
-			return nil, err
-		}
-		outputs[i] = &externalapi.DomainTransactionOutput{
-			Value:           output.Amount,
-			ScriptPublicKey: &externalapi.ScriptPublicKey{Script: scriptPublicKey, Version: output.ScriptPublicKey.Version},
-		}
-	}
-
-	subnetworkIDBytes, err := hex.DecodeString(rpcTransaction.SubnetworkID)
-	if err != nil {
-		return nil, err
-	}
-	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
-	}
-	payload, err := hex.DecodeString(rpcTransaction.Payload)
-	if err != nil {
-		return nil, err
-	}
-
-	return &externalapi.DomainTransaction{
-		Version:      rpcTransaction.Version,
-		Inputs:       inputs,
-		Outputs:      outputs,
-		LockTime:     rpcTransaction.LockTime,
-		SubnetworkID: *subnetworkID,
-		Gas:          rpcTransaction.LockTime,
-		PayloadHash:  *payloadHash,
-		Payload:      payload,
-	}, nil
-}
-
-// DomainTransactionToRPCTransaction converts DomainTransactions to RPCTransactions
-func DomainTransactionToRPCTransaction(transaction *externalapi.DomainTransaction) *RPCTransaction {
-	inputs := make([]*RPCTransactionInput, len(transaction.Inputs))
-	for i, input := range transaction.Inputs {
-		transactionID := input.PreviousOutpoint.TransactionID.String()
-		previousOutpoint := &RPCOutpoint{
-			TransactionID: transactionID,
-			Index:         input.PreviousOutpoint.Index,
-		}
-		signatureScript := hex.EncodeToString(input.SignatureScript)
-		inputs[i] = &RPCTransactionInput{
-			PreviousOutpoint: previousOutpoint,
-			SignatureScript:  signatureScript,
-			Sequence:         input.Sequence,
-		}
-	}
-	outputs := make([]*RPCTransactionOutput, len(transaction.Outputs))
-	for i, output := range transaction.Outputs {
-		scriptPublicKey := hex.EncodeToString(output.ScriptPublicKey.Script)
-		outputs[i] = &RPCTransactionOutput{
-			Amount:          output.Value,
-			ScriptPublicKey: &RPCScriptPublicKey{Script: scriptPublicKey, Version: output.ScriptPublicKey.Version},
-		}
-	}
-	subnetworkID := hex.EncodeToString(transaction.SubnetworkID[:])
-	payloadHash := transaction.PayloadHash.String()
-	payload := hex.EncodeToString(transaction.Payload)
-	return &RPCTransaction{
-		Version:      transaction.Version,
-		Inputs:       inputs,
-		Outputs:      outputs,
-		LockTime:     transaction.LockTime,
-		SubnetworkID: subnetworkID,
-		Gas:          transaction.LockTime,
-		PayloadHash:  payloadHash,
-		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,17 +51,10 @@ const (
 	CmdReject
 	CmdHeader
 	CmdRequestNextHeaders
-	CmdRequestPruningPointUTXOSetAndBlock
-	CmdPruningPointUTXOSetChunk
+	CmdRequestIBDRootUTXOSetAndBlock
+	CmdIBDRootUTXOSetAndBlock
 	CmdRequestIBDBlocks
-	CmdUnexpectedPruningPoint
-	CmdRequestPruningPointHash
-	CmdPruningPointHash
-	CmdIBDBlockLocator
-	CmdIBDBlockLocatorHighestHash
-	CmdBlockHeaders
-	CmdRequestNextPruningPointUTXOSetChunk
-	CmdDonePruningPointUTXOSetChunks
+	CmdIBDRootNotFound
 
 	// rpc
 	CmdGetCurrentNetworkRequestMessage
@@ -86,15 +79,15 @@ const (
 	CmdAddPeerResponseMessage
 	CmdSubmitTransactionRequestMessage
 	CmdSubmitTransactionResponseMessage
-	CmdNotifyVirtualSelectedParentChainChangedRequestMessage
-	CmdNotifyVirtualSelectedParentChainChangedResponseMessage
-	CmdVirtualSelectedParentChainChangedNotificationMessage
+	CmdNotifyChainChangedRequestMessage
+	CmdNotifyChainChangedResponseMessage
+	CmdChainChangedNotificationMessage
 	CmdGetBlockRequestMessage
 	CmdGetBlockResponseMessage
 	CmdGetSubnetworkRequestMessage
 	CmdGetSubnetworkResponseMessage
-	CmdGetVirtualSelectedParentChainFromBlockRequestMessage
-	CmdGetVirtualSelectedParentChainFromBlockResponseMessage
+	CmdGetChainFromBlockRequestMessage
+	CmdGetChainFromBlockResponseMessage
 	CmdGetBlocksRequestMessage
 	CmdGetBlocksResponseMessage
 	CmdGetBlockCountRequestMessage
@@ -113,113 +106,86 @@ const (
 	CmdShutDownResponseMessage
 	CmdGetHeadersRequestMessage
 	CmdGetHeadersResponseMessage
-	CmdNotifyUTXOsChangedRequestMessage
-	CmdNotifyUTXOsChangedResponseMessage
-	CmdUTXOsChangedNotificationMessage
-	CmdGetUTXOsByAddressesRequestMessage
-	CmdGetUTXOsByAddressesResponseMessage
-	CmdGetVirtualSelectedParentBlueScoreRequestMessage
-	CmdGetVirtualSelectedParentBlueScoreResponseMessage
-	CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage
-	CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage
-	CmdVirtualSelectedParentBlueScoreChangedNotificationMessage
 )
 
 // 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",
-	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",
+	CmdIBDRootUTXOSetAndBlock:        "IBDRootUTXOSetAndBlock",
+	CmdRequestIBDBlocks:              "RequestIBDBlocks",
+	CmdIBDRootNotFound:               "IBDRootNotFound",
 }
 
 // RPCMessageCommandToString maps all MessageCommands to their string representation
 var RPCMessageCommandToString = map[MessageCommand]string{
-	CmdGetCurrentNetworkRequestMessage:                            "GetCurrentNetworkRequest",
-	CmdGetCurrentNetworkResponseMessage:                           "GetCurrentNetworkResponse",
-	CmdSubmitBlockRequestMessage:                                  "SubmitBlockRequest",
-	CmdSubmitBlockResponseMessage:                                 "SubmitBlockResponse",
-	CmdGetBlockTemplateRequestMessage:                             "GetBlockTemplateRequest",
-	CmdGetBlockTemplateResponseMessage:                            "GetBlockTemplateResponse",
-	CmdGetBlockTemplateTransactionMessage:                         "CmdGetBlockTemplateTransaction",
-	CmdNotifyBlockAddedRequestMessage:                             "NotifyBlockAddedRequest",
-	CmdNotifyBlockAddedResponseMessage:                            "NotifyBlockAddedResponse",
-	CmdBlockAddedNotificationMessage:                              "BlockAddedNotification",
-	CmdGetPeerAddressesRequestMessage:                             "GetPeerAddressesRequest",
-	CmdGetPeerAddressesResponseMessage:                            "GetPeerAddressesResponse",
-	CmdGetSelectedTipHashRequestMessage:                           "GetSelectedTipHashRequest",
-	CmdGetSelectedTipHashResponseMessage:                          "GetSelectedTipHashResponse",
-	CmdGetMempoolEntryRequestMessage:                              "GetMempoolEntryRequest",
-	CmdGetMempoolEntryResponseMessage:                             "GetMempoolEntryResponse",
-	CmdGetConnectedPeerInfoRequestMessage:                         "GetConnectedPeerInfoRequest",
-	CmdGetConnectedPeerInfoResponseMessage:                        "GetConnectedPeerInfoResponse",
-	CmdAddPeerRequestMessage:                                      "AddPeerRequest",
-	CmdAddPeerResponseMessage:                                     "AddPeerResponse",
-	CmdSubmitTransactionRequestMessage:                            "SubmitTransactionRequest",
-	CmdSubmitTransactionResponseMessage:                           "SubmitTransactionResponse",
-	CmdNotifyVirtualSelectedParentChainChangedRequestMessage:      "NotifyVirtualSelectedParentChainChangedRequest",
-	CmdNotifyVirtualSelectedParentChainChangedResponseMessage:     "NotifyVirtualSelectedParentChainChangedResponse",
-	CmdVirtualSelectedParentChainChangedNotificationMessage:       "VirtualSelectedParentChainChangedNotification",
-	CmdGetBlockRequestMessage:                                     "GetBlockRequest",
-	CmdGetBlockResponseMessage:                                    "GetBlockResponse",
-	CmdGetSubnetworkRequestMessage:                                "GetSubnetworkRequest",
-	CmdGetSubnetworkResponseMessage:                               "GetSubnetworkResponse",
-	CmdGetVirtualSelectedParentChainFromBlockRequestMessage:       "GetVirtualSelectedParentChainFromBlockRequest",
-	CmdGetVirtualSelectedParentChainFromBlockResponseMessage:      "GetVirtualSelectedParentChainFromBlockResponse",
-	CmdGetBlocksRequestMessage:                                    "GetBlocksRequest",
-	CmdGetBlocksResponseMessage:                                   "GetBlocksResponse",
-	CmdGetBlockCountRequestMessage:                                "GetBlockCountRequest",
-	CmdGetBlockCountResponseMessage:                               "GetBlockCountResponse",
-	CmdGetBlockDAGInfoRequestMessage:                              "GetBlockDAGInfoRequest",
-	CmdGetBlockDAGInfoResponseMessage:                             "GetBlockDAGInfoResponse",
-	CmdResolveFinalityConflictRequestMessage:                      "ResolveFinalityConflictRequest",
-	CmdResolveFinalityConflictResponseMessage:                     "ResolveFinalityConflictResponse",
-	CmdNotifyFinalityConflictsRequestMessage:                      "NotifyFinalityConflictsRequest",
-	CmdNotifyFinalityConflictsResponseMessage:                     "NotifyFinalityConflictsResponse",
-	CmdFinalityConflictNotificationMessage:                        "FinalityConflictNotification",
-	CmdFinalityConflictResolvedNotificationMessage:                "FinalityConflictResolvedNotification",
-	CmdGetMempoolEntriesRequestMessage:                            "GetMempoolEntriesRequest",
-	CmdGetMempoolEntriesResponseMessage:                           "GetMempoolEntriesResponse",
-	CmdGetHeadersRequestMessage:                                   "GetHeadersRequest",
-	CmdGetHeadersResponseMessage:                                  "GetHeadersResponse",
-	CmdNotifyUTXOsChangedRequestMessage:                           "NotifyUTXOsChangedRequest",
-	CmdNotifyUTXOsChangedResponseMessage:                          "NotifyUTXOsChangedResponse",
-	CmdUTXOsChangedNotificationMessage:                            "UTXOsChangedNotification",
-	CmdGetUTXOsByAddressesRequestMessage:                          "GetUTXOsByAddressesRequest",
-	CmdGetUTXOsByAddressesResponseMessage:                         "GetUTXOsByAddressesResponse",
-	CmdGetVirtualSelectedParentBlueScoreRequestMessage:            "GetVirtualSelectedParentBlueScoreRequest",
-	CmdGetVirtualSelectedParentBlueScoreResponseMessage:           "GetVirtualSelectedParentBlueScoreResponse",
-	CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage:  "NotifyVirtualSelectedParentBlueScoreChangedRequest",
-	CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage: "NotifyVirtualSelectedParentBlueScoreChangedResponse",
-	CmdVirtualSelectedParentBlueScoreChangedNotificationMessage:   "VirtualSelectedParentBlueScoreChangedNotification",
+	CmdGetCurrentNetworkRequestMessage:             "GetCurrentNetworkRequest",
+	CmdGetCurrentNetworkResponseMessage:            "GetCurrentNetworkResponse",
+	CmdSubmitBlockRequestMessage:                   "SubmitBlockRequest",
+	CmdSubmitBlockResponseMessage:                  "SubmitBlockResponse",
+	CmdGetBlockTemplateRequestMessage:              "GetBlockTemplateRequest",
+	CmdGetBlockTemplateResponseMessage:             "GetBlockTemplateResponse",
+	CmdGetBlockTemplateTransactionMessage:          "CmdGetBlockTemplateTransaction",
+	CmdNotifyBlockAddedRequestMessage:              "NotifyBlockAddedRequest",
+	CmdNotifyBlockAddedResponseMessage:             "NotifyBlockAddedResponse",
+	CmdBlockAddedNotificationMessage:               "BlockAddedNotification",
+	CmdGetPeerAddressesRequestMessage:              "GetPeerAddressesRequest",
+	CmdGetPeerAddressesResponseMessage:             "GetPeerAddressesResponse",
+	CmdGetSelectedTipHashRequestMessage:            "GetSelectedTipHashRequest",
+	CmdGetSelectedTipHashResponseMessage:           "GetSelectedTipHashResponse",
+	CmdGetMempoolEntryRequestMessage:               "GetMempoolEntryRequest",
+	CmdGetMempoolEntryResponseMessage:              "GetMempoolEntryResponse",
+	CmdGetConnectedPeerInfoRequestMessage:          "GetConnectedPeerInfoRequest",
+	CmdGetConnectedPeerInfoResponseMessage:         "GetConnectedPeerInfoResponse",
+	CmdAddPeerRequestMessage:                       "AddPeerRequest",
+	CmdAddPeerResponseMessage:                      "AddPeerResponse",
+	CmdSubmitTransactionRequestMessage:             "SubmitTransactionRequest",
+	CmdSubmitTransactionResponseMessage:            "SubmitTransactionResponse",
+	CmdNotifyChainChangedRequestMessage:            "NotifyChainChangedRequest",
+	CmdNotifyChainChangedResponseMessage:           "NotifyChainChangedResponse",
+	CmdChainChangedNotificationMessage:             "ChainChangedNotification",
+	CmdGetBlockRequestMessage:                      "GetBlockRequest",
+	CmdGetBlockResponseMessage:                     "GetBlockResponse",
+	CmdGetSubnetworkRequestMessage:                 "GetSubnetworkRequest",
+	CmdGetSubnetworkResponseMessage:                "GetSubnetworkResponse",
+	CmdGetChainFromBlockRequestMessage:             "GetChainFromBlockRequest",
+	CmdGetChainFromBlockResponseMessage:            "GetChainFromBlockResponse",
+	CmdGetBlocksRequestMessage:                     "GetBlocksRequest",
+	CmdGetBlocksResponseMessage:                    "GetBlocksResponse",
+	CmdGetBlockCountRequestMessage:                 "GetBlockCountRequest",
+	CmdGetBlockCountResponseMessage:                "GetBlockCountResponse",
+	CmdGetBlockDAGInfoRequestMessage:               "GetBlockDAGInfoRequest",
+	CmdGetBlockDAGInfoResponseMessage:              "GetBlockDAGInfoResponse",
+	CmdResolveFinalityConflictRequestMessage:       "ResolveFinalityConflictRequest",
+	CmdResolveFinalityConflictResponseMessage:      "ResolveFinalityConflictResponse",
+	CmdNotifyFinalityConflictsRequestMessage:       "NotifyFinalityConflictsRequest",
+	CmdNotifyFinalityConflictsResponseMessage:      "NotifyFinalityConflictsResponse",
+	CmdFinalityConflictNotificationMessage:         "FinalityConflictNotification",
+	CmdFinalityConflictResolvedNotificationMessage: "FinalityConflictResolvedNotification",
+	CmdGetMempoolEntriesRequestMessage:             "GetMempoolEntriesRequestMessage",
+	CmdGetMempoolEntriesResponseMessage:            "GetMempoolEntriesResponseMessage",
+	CmdGetHeadersRequestMessage:                    "GetHeadersRequest",
+	CmdGetHeadersResponseMessage:                   "GetHeadersResponse",
 }
 
 // Message is an interface that describes a kaspa message. A type that

app/appmessage/p2p_blockheaders.go

@@ -1,19 +0,0 @@
-package appmessage
-
-// BlockHeadersMessage represents a kaspa BlockHeaders message
-type BlockHeadersMessage struct {
-	baseMessage
-	BlockHeaders []*MsgBlockHeader
-}
-
-// Command returns the protocol command string for the message
-func (msg *BlockHeadersMessage) Command() MessageCommand {
-	return CmdBlockHeaders
-}
-
-// NewBlockHeadersMessage returns a new kaspa BlockHeaders message
-func NewBlockHeadersMessage(blockHeaders []*MsgBlockHeader) *BlockHeadersMessage {
-	return &BlockHeadersMessage{
-		BlockHeaders: blockHeaders,
-	}
-}

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() *MsgDoneHeaders {
+	return &MsgDoneHeaders{}
+}

app/appmessage/p2p_msgblock.go

@@ -71,7 +71,7 @@ func (msg *MsgBlock) MaxPayloadLength(pver uint32) uint32 {
 // Note: this operation modifies the block in place.
 func (msg *MsgBlock) ConvertToPartial(subnetworkID *externalapi.DomainSubnetworkID) {
 	for _, tx := range msg.Transactions {
-		if !tx.SubnetworkID.Equal(subnetworkID) {
+		if tx.SubnetworkID != *subnetworkID {
 			tx.Payload = []byte{}
 		}
 	}

app/appmessage/p2p_msgblock_test.go

@@ -5,15 +5,15 @@
 package appmessage
 
 import (
-	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/util/mstime"
 	"math"
 	"reflect"
 	"testing"
 
 	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
 
+	"github.com/davecgh/go-spew/spew"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/util/mstime"
 )
 
 // TestBlock tests the MsgBlock API.
@@ -110,7 +110,7 @@ func TestConvertToPartial(t *testing.T) {
 	for _, testTransaction := range transactions {
 		var subnetworkTx *MsgTx
 		for _, blockTransaction := range block.Transactions {
-			if blockTransaction.SubnetworkID.Equal(testTransaction.subnetworkID) {
+			if blockTransaction.SubnetworkID == *testTransaction.subnetworkID {
 				subnetworkTx = blockTransaction
 			}
 		}
@@ -127,10 +127,10 @@ func TestConvertToPartial(t *testing.T) {
 	}
 }
 
-//blockOne is the first block in the mainnet block DAG.
+// blockOne is the first block in the mainnet block DAG.
 var blockOne = MsgBlock{
 	Header: MsgBlockHeader{
-		Version:              0,
+		Version:              1,
 		ParentHashes:         []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash},
 		HashMerkleRoot:       mainnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
@@ -156,21 +156,19 @@ var blockOne = MsgBlock{
 			[]*TxOut{
 				{
 					Value: 0x12a05f200,
-					ScriptPubKey: &externalapi.ScriptPublicKey{
-						Script: []byte{
-							0x41, // OP_DATA_65
-							0x04, 0x96, 0xb5, 0x38, 0xe8, 0x53, 0x51, 0x9c,
-							0x72, 0x6a, 0x2c, 0x91, 0xe6, 0x1e, 0xc1, 0x16,
-							0x00, 0xae, 0x13, 0x90, 0x81, 0x3a, 0x62, 0x7c,
-							0x66, 0xfb, 0x8b, 0xe7, 0x94, 0x7b, 0xe6, 0x3c,
-							0x52, 0xda, 0x75, 0x89, 0x37, 0x95, 0x15, 0xd4,
-							0xe0, 0xa6, 0x04, 0xf8, 0x14, 0x17, 0x81, 0xe6,
-							0x22, 0x94, 0x72, 0x11, 0x66, 0xbf, 0x62, 0x1e,
-							0x73, 0xa8, 0x2c, 0xbf, 0x23, 0x42, 0xc8, 0x58,
-							0xee, // 65-byte signature
-							0xac, // OP_CHECKSIG
-						},
-						Version: 0},
+					ScriptPubKey: []byte{
+						0x41, // OP_DATA_65
+						0x04, 0x96, 0xb5, 0x38, 0xe8, 0x53, 0x51, 0x9c,
+						0x72, 0x6a, 0x2c, 0x91, 0xe6, 0x1e, 0xc1, 0x16,
+						0x00, 0xae, 0x13, 0x90, 0x81, 0x3a, 0x62, 0x7c,
+						0x66, 0xfb, 0x8b, 0xe7, 0x94, 0x7b, 0xe6, 0x3c,
+						0x52, 0xda, 0x75, 0x89, 0x37, 0x95, 0x15, 0xd4,
+						0xe0, 0xa6, 0x04, 0xf8, 0x14, 0x17, 0x81, 0xe6,
+						0x22, 0x94, 0x72, 0x11, 0x66, 0xbf, 0x62, 0x1e,
+						0x73, 0xa8, 0x2c, 0xbf, 0x23, 0x42, 0xc8, 0x58,
+						0xee, // 65-byte signature
+						0xac, // OP_CHECKSIG
+					},
 				},
 			}),
 	},
@@ -178,7 +176,7 @@ var blockOne = MsgBlock{
 
 // Block one serialized bytes.
 var blockOneBytes = []byte{
-	0x00, 0x00, // Version 0
+	0x01, 0x00, 0x00, 0x00, // Version 1
 	0x02,                                           // NumParentBlocks
 	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainnetGenesisHash
 	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
@@ -204,7 +202,7 @@ var blockOneBytes = []byte{
 	0xff, 0xff, 0x00, 0x1d, // Bits
 	0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 	0x01,                   // TxnCount
-	0x00, 0x00, 0x00, 0x00, // Version
+	0x01, 0x00, 0x00, 0x00, // Version
 	0x01, // Varint for number of transaction inputs
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

app/appmessage/p2p_msgblockheader.go

@@ -37,7 +37,7 @@ type MsgBlockHeader struct {
 	baseMessage
 
 	// Version of the block. This is not the same as the protocol version.
-	Version uint16
+	Version int32
 
 	// Hashes of the parent block headers in the blockDAG.
 	ParentHashes []*externalapi.DomainHash
@@ -90,7 +90,7 @@ func (h *MsgBlockHeader) Command() MessageCommand {
 // NewBlockHeader returns a new MsgBlockHeader using the provided version, previous
 // block hash, hash merkle root, accepted ID merkle root, difficulty bits, and nonce used to generate the
 // block with defaults or calclulated values for the remaining fields.
-func NewBlockHeader(version uint16, parentHashes []*externalapi.DomainHash, hashMerkleRoot *externalapi.DomainHash,
+func NewBlockHeader(version int32, parentHashes []*externalapi.DomainHash, hashMerkleRoot *externalapi.DomainHash,
 	acceptedIDMerkleRoot *externalapi.DomainHash, utxoCommitment *externalapi.DomainHash, bits uint32, nonce uint64) *MsgBlockHeader {
 
 	// Limit the timestamp to one millisecond precision since the protocol

app/appmessage/p2p_msgblocklocator_test.go

@@ -3,6 +3,8 @@ package appmessage
 import (
 	"testing"
 
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
+
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 
 	"github.com/davecgh/go-spew/spew"
@@ -11,7 +13,7 @@ import (
 // TestBlockLocator tests the MsgBlockLocator API.
 func TestBlockLocator(t *testing.T) {
 	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
-	locatorHash, err := externalapi.NewDomainHashFromString(hashStr)
+	locatorHash, err := hashes.FromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}

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_msgibdblocklocator.go

@@ -1,27 +0,0 @@
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// MsgIBDBlockLocator represents a kaspa ibdBlockLocator message
-type MsgIBDBlockLocator struct {
-	baseMessage
-	TargetHash         *externalapi.DomainHash
-	BlockLocatorHashes []*externalapi.DomainHash
-}
-
-// Command returns the protocol command string for the message
-func (msg *MsgIBDBlockLocator) Command() MessageCommand {
-	return CmdIBDBlockLocator
-}
-
-// NewMsgIBDBlockLocator returns a new kaspa ibdBlockLocator message
-func NewMsgIBDBlockLocator(targetHash *externalapi.DomainHash,
-	blockLocatorHashes []*externalapi.DomainHash) *MsgIBDBlockLocator {
-
-	return &MsgIBDBlockLocator{
-		TargetHash:         targetHash,
-		BlockLocatorHashes: blockLocatorHashes,
-	}
-}

app/appmessage/p2p_msgibdblocklocatorhighesthash.go

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

app/appmessage/p2p_msgibdrootutxosetandblock.go

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

app/appmessage/p2p_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_msgrequestblocklocator_test.go

@@ -4,12 +4,14 @@ import (
 	"testing"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 )
 
 // TestRequestBlockLocator tests the MsgRequestBlockLocator API.
 func TestRequestBlockLocator(t *testing.T) {
 	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
-	highHash, err := externalapi.NewDomainHashFromString(hashStr)
+	highHash, err := hashes.FromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}

app/appmessage/p2p_msgrequestheaders_test.go

@@ -7,26 +7,26 @@ package appmessage
 import (
 	"testing"
 
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 )
 
 // TestRequstIBDBlocks tests the MsgRequestHeaders API.
 func TestRequstIBDBlocks(t *testing.T) {
 	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
-	lowHash, err := externalapi.NewDomainHashFromString(hashStr)
+	lowHash, err := hashes.FromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}
 
 	hashStr = "000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
-	highHash, err := externalapi.NewDomainHashFromString(hashStr)
+	highHash, err := hashes.FromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}
 
 	// Ensure we get the same data back out.
 	msg := NewMsgRequstHeaders(lowHash, highHash)
-	if !msg.HighHash.Equal(highHash) {
+	if *msg.HighHash != *highHash {
 		t.Errorf("NewMsgRequstHeaders: wrong high hash - got %v, want %v",
 			msg.HighHash, highHash)
 	}

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_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_msgtx.go

@@ -6,11 +6,14 @@ package appmessage
 
 import (
 	"encoding/binary"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 	"strconv"
 
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
+
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
+
 	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@@ -38,8 +41,8 @@ const (
 	maxTxInPerMessage = (MaxMessagePayload / minTxInPayload) + 1
 
 	// MinTxOutPayload is the minimum payload size for a transaction output.
-	// Value 8 bytes + version 2 bytes + Varint for ScriptPublicKey length 1 byte.
-	MinTxOutPayload = 11
+	// Value 8 bytes + Varint for ScriptPubKey length 1 byte.
+	MinTxOutPayload = 9
 
 	// maxTxOutPerMessage is the maximum number of transactions outputs that
 	// a transaction which fits into a message could possibly have.
@@ -96,23 +99,23 @@ type TxIn struct {
 // NewTxIn returns a new kaspa transaction input with the provided
 // previous outpoint point and signature script with a default sequence of
 // MaxTxInSequenceNum.
-func NewTxIn(prevOut *Outpoint, signatureScript []byte, sequence uint64) *TxIn {
+func NewTxIn(prevOut *Outpoint, signatureScript []byte) *TxIn {
 	return &TxIn{
 		PreviousOutpoint: *prevOut,
 		SignatureScript:  signatureScript,
-		Sequence:         sequence,
+		Sequence:         constants.MaxTxInSequenceNum,
 	}
 }
 
 // TxOut defines a kaspa transaction output.
 type TxOut struct {
 	Value        uint64
-	ScriptPubKey *externalapi.ScriptPublicKey
+	ScriptPubKey []byte
 }
 
 // NewTxOut returns a new kaspa transaction output with the provided
 // transaction value and public key script.
-func NewTxOut(value uint64, scriptPubKey *externalapi.ScriptPublicKey) *TxOut {
+func NewTxOut(value uint64, scriptPubKey []byte) *TxOut {
 	return &TxOut{
 		Value:        value,
 		ScriptPubKey: scriptPubKey,
@@ -127,7 +130,7 @@ func NewTxOut(value uint64, scriptPubKey *externalapi.ScriptPublicKey) *TxOut {
 // inputs and outputs.
 type MsgTx struct {
 	baseMessage
-	Version      uint16
+	Version      int32
 	TxIn         []*TxIn
 	TxOut        []*TxOut
 	LockTime     uint64
@@ -217,20 +220,20 @@ func (msg *MsgTx) Copy() *MsgTx {
 
 	// Deep copy the old TxOut data.
 	for _, oldTxOut := range msg.TxOut {
-		// Deep copy the old ScriptPublicKey
-		var newScript externalapi.ScriptPublicKey
+		// Deep copy the old ScriptPubKey
+		var newScript []byte
 		oldScript := oldTxOut.ScriptPubKey
-		oldScriptLen := len(oldScript.Script)
+		oldScriptLen := len(oldScript)
 		if oldScriptLen > 0 {
-			newScript = externalapi.ScriptPublicKey{Script: make([]byte, oldScriptLen), Version: oldScript.Version}
-			copy(newScript.Script, oldScript.Script[:oldScriptLen])
+			newScript = make([]byte, oldScriptLen)
+			copy(newScript, oldScript[:oldScriptLen])
 		}
 
 		// Create new txOut with the deep copied data and append it to
 		// new Tx.
 		newTxOut := TxOut{
 			Value:        oldTxOut.Value,
-			ScriptPubKey: &newScript,
+			ScriptPubKey: newScript,
 		}
 		newTx.TxOut = append(newTx.TxOut, &newTxOut)
 	}
@@ -256,8 +259,8 @@ func (msg *MsgTx) MaxPayloadLength(pver uint32) uint32 {
 // 3. The transaction's subnetwork
 func (msg *MsgTx) IsSubnetworkCompatible(subnetworkID *externalapi.DomainSubnetworkID) bool {
 	return subnetworkID == nil ||
-		subnetworkID.Equal(&subnetworks.SubnetworkIDNative) ||
-		subnetworkID.Equal(&msg.SubnetworkID)
+		*subnetworkID == subnetworks.SubnetworkIDNative ||
+		*subnetworkID == msg.SubnetworkID
 }
 
 // newMsgTx returns a new tx message that conforms to the Message interface.
@@ -269,7 +272,7 @@ func (msg *MsgTx) IsSubnetworkCompatible(subnetworkID *externalapi.DomainSubnetw
 // The payload hash is calculated automatically according to provided payload.
 // Also, the lock time is set to zero to indicate the transaction is valid
 // immediately as opposed to some time in future.
-func newMsgTx(version uint16, txIn []*TxIn, txOut []*TxOut, subnetworkID *externalapi.DomainSubnetworkID,
+func newMsgTx(version int32, txIn []*TxIn, txOut []*TxOut, subnetworkID *externalapi.DomainSubnetworkID,
 	gas uint64, payload []byte, lockTime uint64) *MsgTx {
 
 	if txIn == nil {
@@ -282,7 +285,7 @@ func newMsgTx(version uint16, txIn []*TxIn, txOut []*TxOut, subnetworkID *extern
 
 	var payloadHash externalapi.DomainHash
 	if *subnetworkID != subnetworks.SubnetworkIDNative {
-		payloadHash = *hashes.PayloadHash(payload)
+		payloadHash = *hashes.HashData(payload)
 	}
 
 	return &MsgTx{
@@ -298,12 +301,12 @@ func newMsgTx(version uint16, txIn []*TxIn, txOut []*TxOut, subnetworkID *extern
 }
 
 // NewNativeMsgTx returns a new tx message in the native subnetwork
-func NewNativeMsgTx(version uint16, txIn []*TxIn, txOut []*TxOut) *MsgTx {
+func NewNativeMsgTx(version int32, txIn []*TxIn, txOut []*TxOut) *MsgTx {
 	return newMsgTx(version, txIn, txOut, &subnetworks.SubnetworkIDNative, 0, nil, 0)
 }
 
 // NewSubnetworkMsgTx returns a new tx message in the specified subnetwork with specified gas and payload
-func NewSubnetworkMsgTx(version uint16, txIn []*TxIn, txOut []*TxOut, subnetworkID *externalapi.DomainSubnetworkID,
+func NewSubnetworkMsgTx(version int32, txIn []*TxIn, txOut []*TxOut, subnetworkID *externalapi.DomainSubnetworkID,
 	gas uint64, payload []byte) *MsgTx {
 
 	return newMsgTx(version, txIn, txOut, subnetworkID, gas, payload, 0)
@@ -312,12 +315,12 @@ func NewSubnetworkMsgTx(version uint16, txIn []*TxIn, txOut []*TxOut, subnetwork
 // NewNativeMsgTxWithLocktime returns a new tx message in the native subnetwork with a locktime.
 //
 // See newMsgTx for further documntation of the parameters
-func NewNativeMsgTxWithLocktime(version uint16, txIn []*TxIn, txOut []*TxOut, locktime uint64) *MsgTx {
+func NewNativeMsgTxWithLocktime(version int32, txIn []*TxIn, txOut []*TxOut, locktime uint64) *MsgTx {
 	return newMsgTx(version, txIn, txOut, &subnetworks.SubnetworkIDNative, 0, nil, locktime)
 }
 
 // NewRegistryMsgTx creates a new MsgTx that registers a new subnetwork
-func NewRegistryMsgTx(version uint16, txIn []*TxIn, txOut []*TxOut, gasLimit uint64) *MsgTx {
+func NewRegistryMsgTx(version int32, txIn []*TxIn, txOut []*TxOut, gasLimit uint64) *MsgTx {
 	payload := make([]byte, 8)
 	binary.LittleEndian.PutUint64(payload, gasLimit)
 

app/appmessage/p2p_msgtx_test.go

@@ -11,7 +11,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 
 	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
@@ -52,7 +52,7 @@ func TestTx(t *testing.T) {
 	// testing package functionality.
 	prevOutIndex := uint32(1)
 	prevOut := NewOutpoint(txID, prevOutIndex)
-	if !prevOut.TxID.Equal(txID) {
+	if prevOut.TxID != *txID {
 		t.Errorf("NewOutpoint: wrong ID - got %v, want %v",
 			spew.Sprint(&prevOut.TxID), spew.Sprint(txID))
 	}
@@ -68,7 +68,7 @@ func TestTx(t *testing.T) {
 
 	// Ensure we get the same transaction input back out.
 	sigScript := []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62}
-	txIn := NewTxIn(prevOut, sigScript, constants.MaxTxInSequenceNum)
+	txIn := NewTxIn(prevOut, sigScript)
 	if !reflect.DeepEqual(&txIn.PreviousOutpoint, prevOut) {
 		t.Errorf("NewTxIn: wrong prev outpoint - got %v, want %v",
 			spew.Sprint(&txIn.PreviousOutpoint),
@@ -82,28 +82,26 @@ func TestTx(t *testing.T) {
 
 	// Ensure we get the same transaction output back out.
 	txValue := uint64(5000000000)
-	scriptPubKey := &externalapi.ScriptPublicKey{
-		Script: []byte{
-			0x41, // OP_DATA_65
-			0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
-			0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
-			0x81, 0xbe, 0x98, 0x8e, 0x2d, 0xa0, 0xb6, 0xc1,
-			0xc6, 0xa5, 0x9d, 0xc2, 0x26, 0xc2, 0x86, 0x24,
-			0xe1, 0x81, 0x75, 0xe8, 0x51, 0xc9, 0x6b, 0x97,
-			0x3d, 0x81, 0xb0, 0x1c, 0xc3, 0x1f, 0x04, 0x78,
-			0x34, 0xbc, 0x06, 0xd6, 0xd6, 0xed, 0xf6, 0x20,
-			0xd1, 0x84, 0x24, 0x1a, 0x6a, 0xed, 0x8b, 0x63,
-			0xa6, // 65-byte signature
-			0xac, // OP_CHECKSIG
-		},
-		Version: 0}
+	scriptPubKey := []byte{
+		0x41, // OP_DATA_65
+		0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
+		0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
+		0x81, 0xbe, 0x98, 0x8e, 0x2d, 0xa0, 0xb6, 0xc1,
+		0xc6, 0xa5, 0x9d, 0xc2, 0x26, 0xc2, 0x86, 0x24,
+		0xe1, 0x81, 0x75, 0xe8, 0x51, 0xc9, 0x6b, 0x97,
+		0x3d, 0x81, 0xb0, 0x1c, 0xc3, 0x1f, 0x04, 0x78,
+		0x34, 0xbc, 0x06, 0xd6, 0xd6, 0xed, 0xf6, 0x20,
+		0xd1, 0x84, 0x24, 0x1a, 0x6a, 0xed, 0x8b, 0x63,
+		0xa6, // 65-byte signature
+		0xac, // OP_CHECKSIG
+	}
 	txOut := NewTxOut(txValue, scriptPubKey)
 	if txOut.Value != txValue {
 		t.Errorf("NewTxOut: wrong scriptPubKey - got %v, want %v",
 			txOut.Value, txValue)
 
 	}
-	if !bytes.Equal(txOut.ScriptPubKey.Script, scriptPubKey.Script) {
+	if !bytes.Equal(txOut.ScriptPubKey, scriptPubKey) {
 		t.Errorf("NewTxOut: wrong scriptPubKey - got %v, want %v",
 			spew.Sdump(txOut.ScriptPubKey),
 			spew.Sdump(scriptPubKey))
@@ -133,15 +131,11 @@ func TestTx(t *testing.T) {
 
 // TestTxHash tests the ability to generate the hash of a transaction accurately.
 func TestTxHashAndID(t *testing.T) {
-	txHash1Str := "4bee9ee495bd93a755de428376bd582a2bb6ec37c041753b711c0606d5745c13"
-	txID1Str := "f868bd20e816256b80eac976821be4589d24d21141bd1cec6e8005d0c16c6881"
+	txID1Str := "a3d29c39bfb578235e4813cc8138a9ba10def63acad193a7a880159624840d7f"
 	wantTxID1, err := transactionid.FromString(txID1Str)
 	if err != nil {
-		t.Fatalf("NewTxIDFromStr: %v", err)
-	}
-	wantTxHash1, err := transactionid.FromString(txHash1Str)
-	if err != nil {
-		t.Fatalf("NewTxIDFromStr: %v", err)
+		t.Errorf("NewTxIDFromStr: %v", err)
+		return
 	}
 
 	// A coinbase transaction
@@ -155,7 +149,7 @@ func TestTxHashAndID(t *testing.T) {
 	}
 	txOut := &TxOut{
 		Value: 5000000000,
-		ScriptPubKey: &externalapi.ScriptPublicKey{Script: []byte{
+		ScriptPubKey: []byte{
 			0x41, // OP_DATA_65
 			0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
 			0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
@@ -167,32 +161,32 @@ func TestTxHashAndID(t *testing.T) {
 			0xd1, 0x84, 0x24, 0x1a, 0x6a, 0xed, 0x8b, 0x63,
 			0xa6, // 65-byte signature
 			0xac, // OP_CHECKSIG
-		}, Version: 0},
+		},
 	}
-	tx1 := NewSubnetworkMsgTx(0, []*TxIn{txIn}, []*TxOut{txOut}, &subnetworks.SubnetworkIDCoinbase, 0, nil)
+	tx1 := NewSubnetworkMsgTx(1, []*TxIn{txIn}, []*TxOut{txOut}, &subnetworks.SubnetworkIDCoinbase, 0, nil)
 
 	// Ensure the hash produced is expected.
 	tx1Hash := tx1.TxHash()
-	if *tx1Hash != (externalapi.DomainHash)(*wantTxHash1) {
+	if *tx1Hash != (externalapi.DomainHash)(*wantTxID1) {
 		t.Errorf("TxHash: wrong hash - got %v, want %v",
-			spew.Sprint(tx1Hash), spew.Sprint(wantTxHash1))
+			spew.Sprint(tx1Hash), spew.Sprint(wantTxID1))
 	}
 
 	// Ensure the TxID for coinbase transaction is the same as TxHash.
 	tx1ID := tx1.TxID()
-	if !tx1ID.Equal(wantTxID1) {
+	if *tx1ID != *wantTxID1 {
 		t.Errorf("TxID: wrong ID - got %v, want %v",
 			spew.Sprint(tx1ID), spew.Sprint(wantTxID1))
 	}
 
-	hash2Str := "cb1bdb4a83d4885535fb3cceb5c96597b7df903db83f0ffcd779d703affd8efd"
-	wantHash2, err := externalapi.NewDomainHashFromString(hash2Str)
+	hash2Str := "c84f3009b337aaa3adeb2ffd41010d5f62dd773ca25b39c908a77da91f87b729"
+	wantHash2, err := hashes.FromString(hash2Str)
 	if err != nil {
 		t.Errorf("NewTxIDFromStr: %v", err)
 		return
 	}
 
-	id2Str := "ca080073d4ddf5b84443a0964af633f3c70a5b290fd3bc35a7e6f93fd33f9330"
+	id2Str := "7c919f676109743a1271a88beeb43849a6f9cc653f6082e59a7266f3df4802b9"
 	wantID2, err := transactionid.FromString(id2Str)
 	if err != nil {
 		t.Errorf("NewTxIDFromStr: %v", err)
@@ -202,7 +196,7 @@ func TestTxHashAndID(t *testing.T) {
 	txIns := []*TxIn{{
 		PreviousOutpoint: Outpoint{
 			Index: 0,
-			TxID:  *externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{1, 2, 3}),
+			TxID:  externalapi.DomainTransactionID{1, 2, 3},
 		},
 		SignatureScript: []byte{
 			0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xDA, 0x0D, 0xC6, 0xAE, 0xCE, 0xFE, 0x1E, 0x06, 0xEF, 0xDF,
@@ -220,42 +214,42 @@ func TestTxHashAndID(t *testing.T) {
 	txOuts := []*TxOut{
 		{
 			Value: 244623243,
-			ScriptPubKey: &externalapi.ScriptPublicKey{Script: []byte{
+			ScriptPubKey: []byte{
 				0x76, 0xA9, 0x14, 0xBA, 0xDE, 0xEC, 0xFD, 0xEF, 0x05, 0x07, 0x24, 0x7F, 0xC8, 0xF7, 0x42, 0x41,
 				0xD7, 0x3B, 0xC0, 0x39, 0x97, 0x2D, 0x7B, 0x88, 0xAC,
-			}, Version: 0},
+			},
 		},
 		{
 			Value: 44602432,
-			ScriptPubKey: &externalapi.ScriptPublicKey{Script: []byte{
+			ScriptPubKey: []byte{
 				0x76, 0xA9, 0x14, 0xC1, 0x09, 0x32, 0x48, 0x3F, 0xEC, 0x93, 0xED, 0x51, 0xF5, 0xFE, 0x95, 0xE7,
 				0x25, 0x59, 0xF2, 0xCC, 0x70, 0x43, 0xF9, 0x88, 0xAC,
-			}, Version: 0},
+			},
 		},
 	}
 	tx2 := NewSubnetworkMsgTx(1, txIns, txOuts, &externalapi.DomainSubnetworkID{1, 2, 3}, 0, payload)
 
 	// Ensure the hash produced is expected.
 	tx2Hash := tx2.TxHash()
-	if !tx2Hash.Equal(wantHash2) {
+	if *tx2Hash != *wantHash2 {
 		t.Errorf("TxHash: wrong hash - got %v, want %v",
 			spew.Sprint(tx2Hash), spew.Sprint(wantHash2))
 	}
 
 	// Ensure the TxID for coinbase transaction is the same as TxHash.
 	tx2ID := tx2.TxID()
-	if !tx2ID.Equal(wantID2) {
+	if *tx2ID != *wantID2 {
 		t.Errorf("TxID: wrong ID - got %v, want %v",
 			spew.Sprint(tx2ID), spew.Sprint(wantID2))
 	}
 
-	if tx2ID.Equal((*externalapi.DomainTransactionID)(tx2Hash)) {
+	if *tx2ID == (externalapi.DomainTransactionID)(*tx2Hash) {
 		t.Errorf("tx2ID and tx2Hash shouldn't be the same for non-coinbase transaction with signature and/or payload")
 	}
 
 	tx2.TxIn[0].SignatureScript = []byte{}
 	newTx2Hash := tx2.TxHash()
-	if *tx2ID == (externalapi.DomainTransactionID)(*newTx2Hash) {
-		t.Errorf("tx2ID and newTx2Hash should not be the same even for transaction with an empty signature")
+	if *tx2ID != (externalapi.DomainTransactionID)(*newTx2Hash) {
+		t.Errorf("tx2ID and newTx2Hash should be the same for transaction with an empty signature")
 	}
 }

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_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,
 	}
 }
@@ -43,7 +45,7 @@ func NewGetBlockResponseMessage() *GetBlockResponseMessage {
 // BlockVerboseData holds verbose data about a block
 type BlockVerboseData struct {
 	Hash                   string
-	Version                uint16
+	Version                int32
 	VersionHex             string
 	HashMerkleRoot         string
 	AcceptedIDMerkleRoot   string
@@ -57,7 +59,6 @@ type BlockVerboseData struct {
 	ParentHashes           []string
 	SelectedParentHash     string
 	BlueScore              uint64
-	IsHeaderOnly           bool
 }
 
 // TransactionVerboseData holds verbose data about a transaction
@@ -65,7 +66,7 @@ type TransactionVerboseData struct {
 	TxID                      string
 	Hash                      string
 	Size                      uint64
-	Version                   uint16
+	Version                   int32
 	LockTime                  uint64
 	SubnetworkID              string
 	Gas                       uint64
@@ -101,6 +102,7 @@ type TransactionVerboseOutput struct {
 
 // ScriptPubKeyResult holds data about a script public key
 type ScriptPubKeyResult struct {
+	Asm     string
 	Hex     string
 	Type    string
 	Address string

app/appmessage/rpc_get_block_template.go

@@ -24,7 +24,6 @@ func NewGetBlockTemplateRequestMessage(payAddress string) *GetBlockTemplateReque
 type GetBlockTemplateResponseMessage struct {
 	baseMessage
 	MsgBlock *MsgBlock
-	IsSynced bool
 
 	Error *RPCError
 }
@@ -35,9 +34,6 @@ func (msg *GetBlockTemplateResponseMessage) Command() MessageCommand {
 }
 
 // NewGetBlockTemplateResponseMessage returns a instance of the message
-func NewGetBlockTemplateResponseMessage(msgBlock *MsgBlock, isSynced bool) *GetBlockTemplateResponseMessage {
-	return &GetBlockTemplateResponseMessage{
-		MsgBlock: msgBlock,
-		IsSynced: isSynced,
-	}
+func NewGetBlockTemplateResponseMessage(msgBlock *MsgBlock) *GetBlockTemplateResponseMessage {
+	return &GetBlockTemplateResponseMessage{MsgBlock: msgBlock}
 }

app/appmessage/rpc_get_chain_from_block.go

@@ -0,0 +1,49 @@
+package appmessage
+
+// GetChainFromBlockRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetChainFromBlockRequestMessage struct {
+	baseMessage
+	StartHash               string
+	IncludeBlockVerboseData bool
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetChainFromBlockRequestMessage) Command() MessageCommand {
+	return CmdGetChainFromBlockRequestMessage
+}
+
+// NewGetChainFromBlockRequestMessage returns a instance of the message
+func NewGetChainFromBlockRequestMessage(startHash string, includeBlockVerboseData bool) *GetChainFromBlockRequestMessage {
+	return &GetChainFromBlockRequestMessage{
+		StartHash:               startHash,
+		IncludeBlockVerboseData: includeBlockVerboseData,
+	}
+}
+
+// GetChainFromBlockResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetChainFromBlockResponseMessage struct {
+	baseMessage
+	RemovedChainBlockHashes []string
+	AddedChainBlocks        []*ChainBlock
+	BlockVerboseData        []*BlockVerboseData
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetChainFromBlockResponseMessage) Command() MessageCommand {
+	return CmdGetChainFromBlockResponseMessage
+}
+
+// NewGetChainFromBlockResponseMessage returns a instance of the message
+func NewGetChainFromBlockResponseMessage(removedChainBlockHashes []string,
+	addedChainBlocks []*ChainBlock, blockVerboseData []*BlockVerboseData) *GetChainFromBlockResponseMessage {
+
+	return &GetChainFromBlockResponseMessage{
+		RemovedChainBlockHashes: removedChainBlockHashes,
+		AddedChainBlocks:        addedChainBlocks,
+		BlockVerboseData:        blockVerboseData,
+	}
+}

app/appmessage/rpc_get_connected_peer_info.go

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

app/appmessage/rpc_get_utxos_by_addresses.go

@@ -1,41 +0,0 @@
-package appmessage
-
-// GetUTXOsByAddressesRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetUTXOsByAddressesRequestMessage struct {
-	baseMessage
-	Addresses []string
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetUTXOsByAddressesRequestMessage) Command() MessageCommand {
-	return CmdGetUTXOsByAddressesRequestMessage
-}
-
-// NewGetUTXOsByAddressesRequestMessage returns a instance of the message
-func NewGetUTXOsByAddressesRequestMessage(addresses []string) *GetUTXOsByAddressesRequestMessage {
-	return &GetUTXOsByAddressesRequestMessage{
-		Addresses: addresses,
-	}
-}
-
-// GetUTXOsByAddressesResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetUTXOsByAddressesResponseMessage struct {
-	baseMessage
-	Entries []*UTXOsByAddressesEntry
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetUTXOsByAddressesResponseMessage) Command() MessageCommand {
-	return CmdGetUTXOsByAddressesResponseMessage
-}
-
-// NewGetUTXOsByAddressesResponseMessage returns a instance of the message
-func NewGetUTXOsByAddressesResponseMessage(entries []*UTXOsByAddressesEntry) *GetUTXOsByAddressesResponseMessage {
-	return &GetUTXOsByAddressesResponseMessage{
-		Entries: entries,
-	}
-}

app/appmessage/rpc_get_virtual_selected_parent_blue_score.go

@@ -1,38 +0,0 @@
-package appmessage
-
-// GetVirtualSelectedParentBlueScoreRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetVirtualSelectedParentBlueScoreRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetVirtualSelectedParentBlueScoreRequestMessage) Command() MessageCommand {
-	return CmdGetVirtualSelectedParentBlueScoreRequestMessage
-}
-
-// NewGetVirtualSelectedParentBlueScoreRequestMessage returns a instance of the message
-func NewGetVirtualSelectedParentBlueScoreRequestMessage() *GetVirtualSelectedParentBlueScoreRequestMessage {
-	return &GetVirtualSelectedParentBlueScoreRequestMessage{}
-}
-
-// GetVirtualSelectedParentBlueScoreResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetVirtualSelectedParentBlueScoreResponseMessage struct {
-	baseMessage
-	BlueScore uint64
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetVirtualSelectedParentBlueScoreResponseMessage) Command() MessageCommand {
-	return CmdGetVirtualSelectedParentBlueScoreResponseMessage
-}
-
-// NewGetVirtualSelectedParentBlueScoreResponseMessage returns a instance of the message
-func NewGetVirtualSelectedParentBlueScoreResponseMessage(blueScore uint64) *GetVirtualSelectedParentBlueScoreResponseMessage {
-	return &GetVirtualSelectedParentBlueScoreResponseMessage{
-		BlueScore: blueScore,
-	}
-}

app/appmessage/rpc_get_virtual_selected_parent_chain_from_block.go

@@ -1,45 +0,0 @@
-package appmessage
-
-// GetVirtualSelectedParentChainFromBlockRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetVirtualSelectedParentChainFromBlockRequestMessage struct {
-	baseMessage
-	StartHash string
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetVirtualSelectedParentChainFromBlockRequestMessage) Command() MessageCommand {
-	return CmdGetVirtualSelectedParentChainFromBlockRequestMessage
-}
-
-// NewGetVirtualSelectedParentChainFromBlockRequestMessage returns a instance of the message
-func NewGetVirtualSelectedParentChainFromBlockRequestMessage(startHash string) *GetVirtualSelectedParentChainFromBlockRequestMessage {
-	return &GetVirtualSelectedParentChainFromBlockRequestMessage{
-		StartHash: startHash,
-	}
-}
-
-// GetVirtualSelectedParentChainFromBlockResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetVirtualSelectedParentChainFromBlockResponseMessage struct {
-	baseMessage
-	RemovedChainBlockHashes []string
-	AddedChainBlocks        []*ChainBlock
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetVirtualSelectedParentChainFromBlockResponseMessage) Command() MessageCommand {
-	return CmdGetVirtualSelectedParentChainFromBlockResponseMessage
-}
-
-// NewGetVirtualSelectedParentChainFromBlockResponseMessage returns a instance of the message
-func NewGetVirtualSelectedParentChainFromBlockResponseMessage(removedChainBlockHashes []string,
-	addedChainBlocks []*ChainBlock) *GetVirtualSelectedParentChainFromBlockResponseMessage {
-
-	return &GetVirtualSelectedParentChainFromBlockResponseMessage{
-		RemovedChainBlockHashes: removedChainBlockHashes,
-		AddedChainBlocks:        addedChainBlocks,
-	}
-}

app/appmessage/rpc_notify_chain_changed.go

@@ -0,0 +1,69 @@
+package appmessage
+
+// NotifyChainChangedRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyChainChangedRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyChainChangedRequestMessage) Command() MessageCommand {
+	return CmdNotifyChainChangedRequestMessage
+}
+
+// NewNotifyChainChangedRequestMessage returns a instance of the message
+func NewNotifyChainChangedRequestMessage() *NotifyChainChangedRequestMessage {
+	return &NotifyChainChangedRequestMessage{}
+}
+
+// NotifyChainChangedResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyChainChangedResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyChainChangedResponseMessage) Command() MessageCommand {
+	return CmdNotifyChainChangedResponseMessage
+}
+
+// NewNotifyChainChangedResponseMessage returns a instance of the message
+func NewNotifyChainChangedResponseMessage() *NotifyChainChangedResponseMessage {
+	return &NotifyChainChangedResponseMessage{}
+}
+
+// ChainChangedNotificationMessage is an appmessage corresponding to
+// its respective RPC message
+type ChainChangedNotificationMessage struct {
+	baseMessage
+	RemovedChainBlockHashes []string
+	AddedChainBlocks        []*ChainBlock
+}
+
+// ChainBlock represents a DAG chain-block
+type ChainBlock struct {
+	Hash           string
+	AcceptedBlocks []*AcceptedBlock
+}
+
+// AcceptedBlock represents a block accepted into the DAG
+type AcceptedBlock struct {
+	Hash                   string
+	AcceptedTransactionIDs []string
+}
+
+// Command returns the protocol command string for the message
+func (msg *ChainChangedNotificationMessage) Command() MessageCommand {
+	return CmdChainChangedNotificationMessage
+}
+
+// NewChainChangedNotificationMessage returns a instance of the message
+func NewChainChangedNotificationMessage(removedChainBlockHashes []string,
+	addedChainBlocks []*ChainBlock) *ChainChangedNotificationMessage {
+
+	return &ChainChangedNotificationMessage{
+		RemovedChainBlockHashes: removedChainBlockHashes,
+		AddedChainBlocks:        addedChainBlocks,
+	}
+}

app/appmessage/rpc_notify_utxos_changed.go

@@ -1,62 +0,0 @@
-package appmessage
-
-// NotifyUTXOsChangedRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyUTXOsChangedRequestMessage struct {
-	baseMessage
-	Addresses []string
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyUTXOsChangedRequestMessage) Command() MessageCommand {
-	return CmdNotifyUTXOsChangedRequestMessage
-}
-
-// NewNotifyUTXOsChangedRequestMessage returns a instance of the message
-func NewNotifyUTXOsChangedRequestMessage(addresses []string) *NotifyUTXOsChangedRequestMessage {
-	return &NotifyUTXOsChangedRequestMessage{
-		Addresses: addresses,
-	}
-}
-
-// NotifyUTXOsChangedResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyUTXOsChangedResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyUTXOsChangedResponseMessage) Command() MessageCommand {
-	return CmdNotifyUTXOsChangedResponseMessage
-}
-
-// NewNotifyUTXOsChangedResponseMessage returns a instance of the message
-func NewNotifyUTXOsChangedResponseMessage() *NotifyUTXOsChangedResponseMessage {
-	return &NotifyUTXOsChangedResponseMessage{}
-}
-
-// UTXOsChangedNotificationMessage is an appmessage corresponding to
-// its respective RPC message
-type UTXOsChangedNotificationMessage struct {
-	baseMessage
-	Added   []*UTXOsByAddressesEntry
-	Removed []*UTXOsByAddressesEntry
-}
-
-// UTXOsByAddressesEntry represents a UTXO of some address
-type UTXOsByAddressesEntry struct {
-	Address   string
-	Outpoint  *RPCOutpoint
-	UTXOEntry *RPCUTXOEntry
-}
-
-// Command returns the protocol command string for the message
-func (msg *UTXOsChangedNotificationMessage) Command() MessageCommand {
-	return CmdUTXOsChangedNotificationMessage
-}
-
-// NewUTXOsChangedNotificationMessage returns a instance of the message
-func NewUTXOsChangedNotificationMessage() *UTXOsChangedNotificationMessage {
-	return &UTXOsChangedNotificationMessage{}
-}

app/appmessage/rpc_notify_virtual_selected_parent_chain_blue_score_changed.go

@@ -1,55 +0,0 @@
-package appmessage
-
-// NotifyVirtualSelectedParentBlueScoreChangedRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyVirtualSelectedParentBlueScoreChangedRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyVirtualSelectedParentBlueScoreChangedRequestMessage) Command() MessageCommand {
-	return CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage
-}
-
-// NewNotifyVirtualSelectedParentBlueScoreChangedRequestMessage returns a instance of the message
-func NewNotifyVirtualSelectedParentBlueScoreChangedRequestMessage() *NotifyVirtualSelectedParentBlueScoreChangedRequestMessage {
-	return &NotifyVirtualSelectedParentBlueScoreChangedRequestMessage{}
-}
-
-// NotifyVirtualSelectedParentBlueScoreChangedResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyVirtualSelectedParentBlueScoreChangedResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyVirtualSelectedParentBlueScoreChangedResponseMessage) Command() MessageCommand {
-	return CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage
-}
-
-// NewNotifyVirtualSelectedParentBlueScoreChangedResponseMessage returns a instance of the message
-func NewNotifyVirtualSelectedParentBlueScoreChangedResponseMessage() *NotifyVirtualSelectedParentBlueScoreChangedResponseMessage {
-	return &NotifyVirtualSelectedParentBlueScoreChangedResponseMessage{}
-}
-
-// VirtualSelectedParentBlueScoreChangedNotificationMessage is an appmessage corresponding to
-// its respective RPC message
-type VirtualSelectedParentBlueScoreChangedNotificationMessage struct {
-	baseMessage
-	VirtualSelectedParentBlueScore uint64
-}
-
-// Command returns the protocol command string for the message
-func (msg *VirtualSelectedParentBlueScoreChangedNotificationMessage) Command() MessageCommand {
-	return CmdVirtualSelectedParentBlueScoreChangedNotificationMessage
-}
-
-// NewVirtualSelectedParentBlueScoreChangedNotificationMessage returns a instance of the message
-func NewVirtualSelectedParentBlueScoreChangedNotificationMessage(
-	virtualSelectedParentBlueScore uint64) *VirtualSelectedParentBlueScoreChangedNotificationMessage {
-
-	return &VirtualSelectedParentBlueScoreChangedNotificationMessage{
-		VirtualSelectedParentBlueScore: virtualSelectedParentBlueScore,
-	}
-}

app/appmessage/rpc_notify_virtual_selected_parent_chain_changed.go

@@ -1,69 +0,0 @@
-package appmessage
-
-// NotifyVirtualSelectedParentChainChangedRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyVirtualSelectedParentChainChangedRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyVirtualSelectedParentChainChangedRequestMessage) Command() MessageCommand {
-	return CmdNotifyVirtualSelectedParentChainChangedRequestMessage
-}
-
-// NewNotifyVirtualSelectedParentChainChangedRequestMessage returns a instance of the message
-func NewNotifyVirtualSelectedParentChainChangedRequestMessage() *NotifyVirtualSelectedParentChainChangedRequestMessage {
-	return &NotifyVirtualSelectedParentChainChangedRequestMessage{}
-}
-
-// NotifyVirtualSelectedParentChainChangedResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyVirtualSelectedParentChainChangedResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyVirtualSelectedParentChainChangedResponseMessage) Command() MessageCommand {
-	return CmdNotifyVirtualSelectedParentChainChangedResponseMessage
-}
-
-// NewNotifyVirtualSelectedParentChainChangedResponseMessage returns a instance of the message
-func NewNotifyVirtualSelectedParentChainChangedResponseMessage() *NotifyVirtualSelectedParentChainChangedResponseMessage {
-	return &NotifyVirtualSelectedParentChainChangedResponseMessage{}
-}
-
-// VirtualSelectedParentChainChangedNotificationMessage is an appmessage corresponding to
-// its respective RPC message
-type VirtualSelectedParentChainChangedNotificationMessage struct {
-	baseMessage
-	RemovedChainBlockHashes []string
-	AddedChainBlocks        []*ChainBlock
-}
-
-// ChainBlock represents a DAG chain-block
-type ChainBlock struct {
-	Hash           string
-	AcceptedBlocks []*AcceptedBlock
-}
-
-// AcceptedBlock represents a block accepted into the DAG
-type AcceptedBlock struct {
-	Hash                   string
-	AcceptedTransactionIDs []string
-}
-
-// Command returns the protocol command string for the message
-func (msg *VirtualSelectedParentChainChangedNotificationMessage) Command() MessageCommand {
-	return CmdVirtualSelectedParentChainChangedNotificationMessage
-}
-
-// NewVirtualSelectedParentChainChangedNotificationMessage returns a instance of the message
-func NewVirtualSelectedParentChainChangedNotificationMessage(removedChainBlockHashes []string,
-	addedChainBlocks []*ChainBlock) *VirtualSelectedParentChainChangedNotificationMessage {
-
-	return &VirtualSelectedParentChainChangedNotificationMessage{
-		RemovedChainBlockHashes: removedChainBlockHashes,
-		AddedChainBlocks:        addedChainBlocks,
-	}
-}

app/appmessage/rpc_submit_block.go

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

app/appmessage/rpc_submit_transaction.go

@@ -4,7 +4,7 @@ package appmessage
 // its respective RPC message
 type SubmitTransactionRequestMessage struct {
 	baseMessage
-	Transaction *RPCTransaction
+	Transaction *MsgTx
 }
 
 // Command returns the protocol command string for the message
@@ -13,7 +13,7 @@ func (msg *SubmitTransactionRequestMessage) Command() MessageCommand {
 }
 
 // NewSubmitTransactionRequestMessage returns a instance of the message
-func NewSubmitTransactionRequestMessage(transaction *RPCTransaction) *SubmitTransactionRequestMessage {
+func NewSubmitTransactionRequestMessage(transaction *MsgTx) *SubmitTransactionRequestMessage {
 	return &SubmitTransactionRequestMessage{
 		Transaction: transaction,
 	}
@@ -23,7 +23,7 @@ func NewSubmitTransactionRequestMessage(transaction *RPCTransaction) *SubmitTran
 // its respective RPC message
 type SubmitTransactionResponseMessage struct {
 	baseMessage
-	TransactionID string
+	TxID string
 
 	Error *RPCError
 }
@@ -34,58 +34,8 @@ func (msg *SubmitTransactionResponseMessage) Command() MessageCommand {
 }
 
 // NewSubmitTransactionResponseMessage returns a instance of the message
-func NewSubmitTransactionResponseMessage(transactionID string) *SubmitTransactionResponseMessage {
+func NewSubmitTransactionResponseMessage(txID string) *SubmitTransactionResponseMessage {
 	return &SubmitTransactionResponseMessage{
-		TransactionID: transactionID,
+		TxID: txID,
 	}
 }
-
-// RPCTransaction is a kaspad transaction representation meant to be
-// used over RPC
-type RPCTransaction struct {
-	Version      uint16
-	Inputs       []*RPCTransactionInput
-	Outputs      []*RPCTransactionOutput
-	LockTime     uint64
-	SubnetworkID string
-	Gas          uint64
-	PayloadHash  string
-	Payload      string
-}
-
-// RPCTransactionInput is a kaspad transaction input representation
-// meant to be used over RPC
-type RPCTransactionInput struct {
-	PreviousOutpoint *RPCOutpoint
-	SignatureScript  string
-	Sequence         uint64
-}
-
-// RPCScriptPublicKey is a kaspad ScriptPublicKey representation
-type RPCScriptPublicKey struct {
-	Version uint16
-	Script  string
-}
-
-// RPCTransactionOutput is a kaspad transaction output representation
-// meant to be used over RPC
-type RPCTransactionOutput struct {
-	Amount          uint64
-	ScriptPublicKey *RPCScriptPublicKey
-}
-
-// RPCOutpoint is a kaspad outpoint representation meant to be used
-// over RPC
-type RPCOutpoint struct {
-	TransactionID string
-	Index         uint32
-}
-
-// RPCUTXOEntry is a kaspad utxo entry representation meant to be used
-// over RPC
-type RPCUTXOEntry struct {
-	Amount          uint64
-	ScriptPublicKey *RPCScriptPublicKey
-	BlockBlueScore  uint64
-	IsCoinbase      bool
-}

app/component_manager.go

@@ -4,8 +4,6 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/kaspanet/kaspad/domain/utxoindex"
-
 	infrastructuredatabase "github.com/kaspanet/kaspad/infrastructure/db/database"
 
 	"github.com/kaspanet/kaspad/domain"
@@ -80,7 +78,7 @@ func (a *ComponentManager) Stop() {
 func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database, interrupt chan<- struct{}) (
 	*ComponentManager, error) {
 
-	domain, err := domain.New(cfg.ActiveNetParams, db, cfg.IsArchivalNode)
+	domain, err := domain.New(cfg.ActiveNetParams, db)
 	if err != nil {
 		return nil, err
 	}
@@ -95,12 +93,6 @@ func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database,
 		return nil, err
 	}
 
-	var utxoIndex *utxoindex.UTXOIndex
-	if cfg.UTXOIndex {
-		utxoIndex = utxoindex.New(domain.Consensus(), db)
-		log.Infof("UTXO index started")
-	}
-
 	connectionManager, err := connmanager.New(cfg, netAdapter, addressManager)
 	if err != nil {
 		return nil, err
@@ -109,7 +101,7 @@ func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database,
 	if err != nil {
 		return nil, err
 	}
-	rpcManager := setupRPC(cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, utxoIndex, interrupt)
+	rpcManager := setupRPC(cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, interrupt)
 
 	return &ComponentManager{
 		cfg:               cfg,
@@ -129,20 +121,11 @@ func setupRPC(
 	protocolManager *protocol.Manager,
 	connectionManager *connmanager.ConnectionManager,
 	addressManager *addressmanager.AddressManager,
-	utxoIndex *utxoindex.UTXOIndex,
 	shutDownChan chan<- struct{},
 ) *rpc.Manager {
 
 	rpcManager := rpc.NewManager(
-		cfg,
-		domain,
-		netAdapter,
-		protocolManager,
-		connectionManager,
-		addressManager,
-		utxoIndex,
-		shutDownChan,
-	)
+		cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, shutDownChan)
 	protocolManager.SetOnBlockAddedToDAGHandler(rpcManager.NotifyBlockAddedToDAG)
 
 	return rpcManager

app/protocol/blocklogger/blocklogger.go

@@ -50,7 +50,7 @@ func LogBlock(block *externalapi.DomainBlock) {
 
 	log.Infof("Processed %d %s in the last %s (%d %s, %s)",
 		receivedLogBlocks, blockStr, tDuration, receivedLogTx,
-		txStr, mstime.UnixMilliseconds(block.Header.TimeInMilliseconds()))
+		txStr, mstime.UnixMilliseconds(block.Header.TimeInMilliseconds))
 
 	receivedLogBlocks = 0
 	receivedLogTx = 0

app/protocol/flowcontext/blocks.go

@@ -1,8 +1,9 @@
 package flowcontext
 
 import (
+	"sync/atomic"
+
 	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/pkg/errors"
 
@@ -16,40 +17,27 @@ import (
 // OnNewBlock updates the mempool after a new block arrival, and
 // relays newly unorphaned transactions and possibly rebroadcast
 // manually added transactions when not in IBD.
-func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock,
-	blockInsertionResult *externalapi.BlockInsertionResult) error {
-
+func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock) error {
 	hash := consensushashing.BlockHash(block)
 	log.Debugf("OnNewBlock start for block %s", hash)
 	defer log.Debugf("OnNewBlock end for block %s", hash)
-
-	unorphaningResults, err := f.UnorphanBlocks(block)
+	unorphanedBlocks, err := f.UnorphanBlocks(block)
 	if err != nil {
 		return err
 	}
 
-	log.Debugf("OnNewBlock: block %s unorphaned %d blocks", hash, len(unorphaningResults))
+	log.Debugf("OnNewBlock: block %s unorphaned %d blocks", hash, len(unorphanedBlocks))
 
-	newBlocks := []*externalapi.DomainBlock{block}
-	newBlockInsertionResults := []*externalapi.BlockInsertionResult{blockInsertionResult}
-	for _, unorphaningResult := range unorphaningResults {
-		newBlocks = append(newBlocks, unorphaningResult.block)
-		newBlockInsertionResults = append(newBlockInsertionResults, unorphaningResult.blockInsertionResult)
-	}
-
-	for i, newBlock := range newBlocks {
+	newBlocks := append([]*externalapi.DomainBlock{block}, unorphanedBlocks...)
+	for _, 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 {
-			return err
-		}
+		log.Tracef("OnNewBlock: passing block %s transactions to mining manager", hash)
+		_ = f.Domain().MiningManager().HandleNewBlockTransactions(newBlock.Transactions)
 
 		if f.onBlockAddedToDAGHandler != nil {
-			log.Debugf("OnNewBlock: calling f.onBlockAddedToDAGHandler for block %s", hash)
-			blockInsertionResult = newBlockInsertionResults[i]
-			err := f.onBlockAddedToDAGHandler(newBlock, blockInsertionResult)
+			log.Tracef("OnNewBlock: calling f.onBlockAddedToDAGHandler for block %s", hash)
+			err := f.onBlockAddedToDAGHandler(newBlock)
 			if err != nil {
 				return err
 			}
@@ -101,14 +89,15 @@ 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 {
-	blockInsertionResult, err := f.Domain().Consensus().ValidateAndInsertBlock(block)
+	_, err := f.Domain().Consensus().ValidateAndInsertBlock(block)
 	if err != nil {
 		if errors.As(err, &ruleerrors.RuleError{}) {
-			log.Warnf("Validation failed for block %s: %s", consensushashing.BlockHash(block), err)
+			log.Infof("Validation failed for block %s: %s", consensushashing.BlockHash(block), err)
+			return nil
 		}
 		return err
 	}
-	err = f.OnNewBlock(block, blockInsertionResult)
+	err = f.OnNewBlock(block)
 	if err != nil {
 		return err
 	}
@@ -117,45 +106,24 @@ func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
 
 // IsIBDRunning returns true if IBD is currently marked as running
 func (f *FlowContext) IsIBDRunning() bool {
-	f.ibdPeerMutex.RLock()
-	defer f.ibdPeerMutex.RUnlock()
-
-	return f.ibdPeer != nil
+	return atomic.LoadUint32(&f.isInIBD) != 0
 }
 
 // TrySetIBDRunning attempts to set `isInIBD`. Returns false
 // if it is already set
-func (f *FlowContext) TrySetIBDRunning(ibdPeer *peerpkg.Peer) bool {
-	f.ibdPeerMutex.Lock()
-	defer f.ibdPeerMutex.Unlock()
-
-	if f.ibdPeer != nil {
-		return false
+func (f *FlowContext) TrySetIBDRunning() bool {
+	succeeded := atomic.CompareAndSwapUint32(&f.isInIBD, 0, 1)
+	if succeeded {
+		log.Infof("IBD started")
 	}
-	f.ibdPeer = ibdPeer
-	log.Infof("IBD started")
-
-	return true
+	return succeeded
 }
 
 // UnsetIBDRunning unsets isInIBD
 func (f *FlowContext) UnsetIBDRunning() {
-	f.ibdPeerMutex.Lock()
-	defer f.ibdPeerMutex.Unlock()
-
-	if f.ibdPeer == nil {
+	succeeded := atomic.CompareAndSwapUint32(&f.isInIBD, 1, 0)
+	if !succeeded {
 		panic("attempted to unset isInIBD when it was not set to begin with")
 	}
-
-	f.ibdPeer = nil
 	log.Infof("IBD finished")
 }
-
-// IBDPeer returns the current IBD peer or null if the node is not
-// in IBD
-func (f *FlowContext) IBDPeer() *peerpkg.Peer {
-	f.ibdPeerMutex.RLock()
-	defer f.ibdPeerMutex.RUnlock()
-
-	return f.ibdPeer
-}

app/protocol/flowcontext/errors.go

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

app/protocol/flowcontext/flow_context.go

@@ -1,7 +1,6 @@
 package flowcontext
 
 import (
-	"github.com/kaspanet/kaspad/util/mstime"
 	"sync"
 	"time"
 
@@ -21,7 +20,7 @@ import (
 
 // OnBlockAddedToDAGHandler is a handler function that's triggered
 // when a block is added to the DAG
-type OnBlockAddedToDAGHandler func(block *externalapi.DomainBlock, blockInsertionResult *externalapi.BlockInsertionResult) error
+type OnBlockAddedToDAGHandler func(block *externalapi.DomainBlock) error
 
 // OnTransactionAddedToMempoolHandler is a handler function that's triggered
 // when a transaction is added to the mempool
@@ -36,8 +35,6 @@ type FlowContext struct {
 	addressManager    *addressmanager.AddressManager
 	connectionManager *connmanager.ConnectionManager
 
-	timeStarted int64
-
 	onBlockAddedToDAGHandler           OnBlockAddedToDAGHandler
 	onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler
 
@@ -48,8 +45,7 @@ type FlowContext struct {
 
 	sharedRequestedBlocks *blockrelay.SharedRequestedBlocks
 
-	ibdPeer      *peerpkg.Peer
-	ibdPeerMutex sync.RWMutex
+	isInIBD uint32
 
 	peers      map[id.ID]*peerpkg.Peer
 	peersMutex sync.RWMutex
@@ -73,7 +69,6 @@ func New(cfg *config.Config, domain domain.Domain, addressManager *addressmanage
 		peers:                       make(map[id.ID]*peerpkg.Peer),
 		transactionsToRebroadcast:   make(map[externalapi.DomainTransactionID]*externalapi.DomainTransaction),
 		orphans:                     make(map[externalapi.DomainHash]*externalapi.DomainBlock),
-		timeStarted:                 mstime.Now().UnixMilliseconds(),
 	}
 }
 

app/protocol/flowcontext/orphans.go

@@ -4,23 +4,9 @@ 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"
 )
 
-// maxOrphans is the maximum amount of orphans allowed in the
-// orphans collection. This number is an approximation of how
-// many orphans there can possibly be on average. It is based
-// on: 2^orphanResolutionRange * PHANTOM K.
-const maxOrphans = 600
-
-// UnorphaningResult is the result of unorphaning a block
-type UnorphaningResult struct {
-	block                *externalapi.DomainBlock
-	blockInsertionResult *externalapi.BlockInsertionResult
-}
-
 // AddOrphan adds the block to the orphan set
 func (f *FlowContext) AddOrphan(orphanBlock *externalapi.DomainBlock) {
 	f.orphansMutex.Lock()
@@ -29,24 +15,9 @@ func (f *FlowContext) AddOrphan(orphanBlock *externalapi.DomainBlock) {
 	orphanHash := consensushashing.BlockHash(orphanBlock)
 	f.orphans[*orphanHash] = orphanBlock
 
-	if len(f.orphans) > maxOrphans {
-		log.Debugf("Orphan collection size exceeded. Evicting a random orphan")
-		f.evictRandomOrphan()
-	}
-
 	log.Infof("Received a block with missing parents, adding to orphan pool: %s", orphanHash)
 }
 
-func (f *FlowContext) evictRandomOrphan() {
-	var toEvict externalapi.DomainHash
-	for hash := range f.orphans {
-		toEvict = hash
-		break
-	}
-	delete(f.orphans, toEvict)
-	log.Debugf("Evicted %s from the orphan collection", toEvict)
-}
-
 // IsOrphan returns whether the given blockHash belongs to an orphan block
 func (f *FlowContext) IsOrphan(blockHash *externalapi.DomainHash) bool {
 	f.orphansMutex.RLock()
@@ -57,7 +28,7 @@ func (f *FlowContext) IsOrphan(blockHash *externalapi.DomainHash) bool {
 }
 
 // UnorphanBlocks removes the block from the orphan set, and remove all of the blocks that are not orphans anymore.
-func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*UnorphaningResult, error) {
+func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*externalapi.DomainBlock, error) {
 	f.orphansMutex.Lock()
 	defer f.orphansMutex.Unlock()
 
@@ -66,23 +37,23 @@ func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*Uno
 	rootBlockHash := consensushashing.BlockHash(rootBlock)
 	processQueue := f.addChildOrphansToProcessQueue(rootBlockHash, []externalapi.DomainHash{})
 
-	var unorphaningResults []*UnorphaningResult
+	var unorphanedBlocks []*externalapi.DomainBlock
 	for len(processQueue) > 0 {
 		var orphanHash externalapi.DomainHash
 		orphanHash, processQueue = processQueue[0], processQueue[1:]
 		orphanBlock := f.orphans[orphanHash]
 
-		log.Debugf("Considering to unorphan block %s with parents %s",
-			orphanHash, orphanBlock.Header.ParentHashes())
+		log.Tracef("Considering to unorphan block %s with parents %s",
+			orphanHash, orphanBlock.Header.ParentHashes)
 
 		canBeUnorphaned := true
-		for _, orphanBlockParentHash := range orphanBlock.Header.ParentHashes() {
+		for _, orphanBlockParentHash := range orphanBlock.Header.ParentHashes {
 			orphanBlockParentInfo, err := f.domain.Consensus().GetBlockInfo(orphanBlockParentHash)
 			if err != nil {
 				return nil, err
 			}
 			if !orphanBlockParentInfo.Exists || orphanBlockParentInfo.BlockStatus == externalapi.StatusHeaderOnly {
-				log.Debugf("Cannot unorphan block %s. It's missing at "+
+				log.Tracef("Cannot unorphan block %s. It's missing at "+
 					"least the following parent: %s", orphanHash, orphanBlockParentHash)
 
 				canBeUnorphaned = false
@@ -90,21 +61,16 @@ func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*Uno
 			}
 		}
 		if canBeUnorphaned {
-			blockInsertionResult, unorphaningSucceeded, err := f.unorphanBlock(orphanHash)
+			err := f.unorphanBlock(orphanHash)
 			if err != nil {
 				return nil, err
 			}
-			if unorphaningSucceeded {
-				unorphaningResults = append(unorphaningResults, &UnorphaningResult{
-					block:                orphanBlock,
-					blockInsertionResult: blockInsertionResult,
-				})
-				processQueue = f.addChildOrphansToProcessQueue(&orphanHash, processQueue)
-			}
+			unorphanedBlocks = append(unorphanedBlocks, orphanBlock)
+			processQueue = f.addChildOrphansToProcessQueue(&orphanHash, processQueue)
 		}
 	}
 
-	return unorphaningResults, nil
+	return unorphanedBlocks, nil
 }
 
 // addChildOrphansToProcessQueue finds all child orphans of `blockHash`
@@ -133,8 +99,8 @@ func (f *FlowContext) addChildOrphansToProcessQueue(blockHash *externalapi.Domai
 func (f *FlowContext) findChildOrphansOfBlock(blockHash *externalapi.DomainHash) []externalapi.DomainHash {
 	var childOrphans []externalapi.DomainHash
 	for orphanHash, orphanBlock := range f.orphans {
-		for _, orphanBlockParentHash := range orphanBlock.Header.ParentHashes() {
-			if orphanBlockParentHash.Equal(blockHash) {
+		for _, orphanBlockParentHash := range orphanBlock.Header.ParentHashes {
+			if *orphanBlockParentHash == *blockHash {
 				childOrphans = append(childOrphans, orphanHash)
 				break
 			}
@@ -143,68 +109,22 @@ func (f *FlowContext) findChildOrphansOfBlock(blockHash *externalapi.DomainHash)
 	return childOrphans
 }
 
-func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) (*externalapi.BlockInsertionResult, bool, error) {
+func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) error {
 	orphanBlock, ok := f.orphans[orphanHash]
 	if !ok {
-		return nil, false, errors.Errorf("attempted to unorphan a non-orphan block %s", orphanHash)
+		return errors.Errorf("attempted to unorphan a non-orphan block %s", orphanHash)
 	}
 	delete(f.orphans, orphanHash)
 
-	blockInsertionResult, err := f.domain.Consensus().ValidateAndInsertBlock(orphanBlock)
+	_, err := f.domain.Consensus().ValidateAndInsertBlock(orphanBlock)
 	if err != nil {
 		if errors.As(err, &ruleerrors.RuleError{}) {
-			log.Warnf("Validation failed for orphan block %s: %s", orphanHash, err)
-			return nil, false, nil
+			log.Infof("Validation failed for orphan block %s: %s", orphanHash, err)
+			return nil
 		}
-		return nil, false, err
+		return err
 	}
 
 	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)
-			}
-			continue
-		}
-
-		for _, parent := range block.Header.ParentHashes() {
-			if !addedToQueueSet.Contains(parent) {
-				queue = append(queue, parent)
-				addedToQueueSet.Add(parent)
-			}
-		}
-	}
-
-	return roots, true, nil
+	return nil
 }

app/protocol/flowcontext/should_mine.go

@@ -1,43 +0,0 @@
-package flowcontext
-
-import "github.com/kaspanet/kaspad/util/mstime"
-
-const (
-	maxSelectedParentTimeDiffToAllowMiningInMilliSeconds = 60 * 60 * 1000 // 1 Hour
-)
-
-// ShouldMine returns whether it's ok to use block template from this node
-// for mining purposes.
-func (f *FlowContext) ShouldMine() (bool, error) {
-	peers := f.Peers()
-	if len(peers) == 0 {
-		log.Debugf("The node is not connected, so ShouldMine returns false")
-		return false, nil
-	}
-
-	if f.IsIBDRunning() {
-		log.Debugf("IBD is running, so ShouldMine returns false")
-		return false, nil
-	}
-
-	virtualSelectedParent, err := f.domain.Consensus().GetVirtualSelectedParent()
-	if err != nil {
-		return false, err
-	}
-
-	virtualSelectedParentHeader, err := f.domain.Consensus().GetBlockHeader(virtualSelectedParent)
-	if err != nil {
-		return false, err
-	}
-
-	now := mstime.Now().UnixMilliseconds()
-	if now-virtualSelectedParentHeader.TimeInMilliseconds() < maxSelectedParentTimeDiffToAllowMiningInMilliSeconds {
-		log.Debugf("The selected tip timestamp is recent (%d), so ShouldMine returns true",
-			virtualSelectedParentHeader.TimeInMilliseconds())
-		return true, nil
-	}
-
-	log.Debugf("The selected tip timestamp is old (%d), so ShouldMine returns false",
-		virtualSelectedParentHeader.TimeInMilliseconds())
-	return false, nil
-}

app/protocol/flows/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
 }
 

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

@@ -1,77 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleIBDBlockLocatorContext is the interface for the context needed for the HandleIBDBlockLocator flow.
-type HandleIBDBlockLocatorContext interface {
-	Domain() domain.Domain
-}
-
-// HandleIBDBlockLocator listens to appmessage.MsgIBDBlockLocator messages and sends
-// the highest known block that's in the selected parent chain of `targetHash` to the
-// requesting peer.
-func HandleIBDBlockLocator(context HandleIBDBlockLocatorContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route, peer *peer.Peer) error {
-
-	for {
-		message, err := incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-		ibdBlockLocatorMessage := message.(*appmessage.MsgIBDBlockLocator)
-
-		targetHash := ibdBlockLocatorMessage.TargetHash
-		log.Debugf("Received IBDBlockLocator from %s with targetHash %s", peer, targetHash)
-
-		blockInfo, err := context.Domain().Consensus().GetBlockInfo(targetHash)
-		if err != nil {
-			return err
-		}
-		if !blockInfo.Exists {
-			return protocolerrors.Errorf(true, "received IBDBlockLocator "+
-				"with an unknown targetHash %s", targetHash)
-		}
-
-		foundHighestHashInTheSelectedParentChainOfTargetHash := false
-		for _, blockLocatorHash := range ibdBlockLocatorMessage.BlockLocatorHashes {
-			blockInfo, err := context.Domain().Consensus().GetBlockInfo(blockLocatorHash)
-			if err != nil {
-				return err
-			}
-			if !blockInfo.Exists {
-				continue
-			}
-
-			isBlockLocatorHashInSelectedParentChainOfHighHash, err :=
-				context.Domain().Consensus().IsInSelectedParentChainOf(blockLocatorHash, targetHash)
-			if err != nil {
-				return err
-			}
-			if !isBlockLocatorHashInSelectedParentChainOfHighHash {
-				continue
-			}
-
-			foundHighestHashInTheSelectedParentChainOfTargetHash = true
-			log.Debugf("Found a known hash %s amongst peer %s's "+
-				"blockLocator that's in the selected parent chain of targetHash %s", blockLocatorHash, peer, targetHash)
-
-			ibdBlockLocatorHighestHashMessage := appmessage.NewMsgIBDBlockLocatorHighestHash(blockLocatorHash)
-			err = outgoingRoute.Enqueue(ibdBlockLocatorHighestHashMessage)
-			if err != nil {
-				return err
-			}
-			break
-		}
-
-		if !foundHighestHashInTheSelectedParentChainOfTargetHash {
-			return protocolerrors.Errorf(true, "no hash was found in the blockLocator "+
-				"that was in the selected parent chain of targetHash %s", targetHash)
-		}
-	}
-}

app/protocol/flows/blockrelay/handle_ibd_block_requests.go

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

app/protocol/flows/blockrelay/handle_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_block_requests.go

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

app/protocol/flows/blockrelay/handle_relay_invs.go

@@ -10,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,14 +24,14 @@ var orphanResolutionRange uint32 = 5
 type RelayInvsContext interface {
 	Domain() domain.Domain
 	Config() *config.Config
-	OnNewBlock(block *externalapi.DomainBlock, blockInsertionResult *externalapi.BlockInsertionResult) error
+	NetAdapter() *netadapter.NetAdapter
+	OnNewBlock(block *externalapi.DomainBlock) 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
+	TrySetIBDRunning() bool
 	UnsetIBDRunning()
 }
 
@@ -70,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)
@@ -80,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,16 +102,12 @@ func (flow *handleRelayInvsFlow) start() error {
 		}
 
 		log.Debugf("Processing block %s", inv.Hash)
-		missingParents, blockInsertionResult, err := flow.processBlock(block)
+		missingParents, err := flow.processBlock(block)
 		if err != nil {
-			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
@@ -128,7 +121,7 @@ func (flow *handleRelayInvsFlow) start() error {
 			return err
 		}
 		log.Infof("Accepted block %s via relay", inv.Hash)
-		err = flow.OnNewBlock(block, blockInsertionResult)
+		err = flow.OnNewBlock(block)
 		if err != nil {
 			return err
 		}
@@ -178,7 +171,7 @@ func (flow *handleRelayInvsFlow) requestBlock(requestHash *externalapi.DomainHas
 
 	block := appmessage.MsgBlockToDomainBlock(msgBlock)
 	blockHash := consensushashing.BlockHash(block)
-	if !blockHash.Equal(requestHash) {
+	if *blockHash != *requestHash {
 		return nil, false, protocolerrors.Errorf(true, "got unrequested block %s", blockHash)
 	}
 
@@ -206,22 +199,22 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock,
 	}
 }
 
-func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, *externalapi.BlockInsertionResult, error) {
+func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, error) {
 	blockHash := consensushashing.BlockHash(block)
-	blockInsertionResult, err := flow.Domain().Consensus().ValidateAndInsertBlock(block)
+	_, err := flow.Domain().Consensus().ValidateAndInsertBlock(block)
 	if err != nil {
 		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return nil, nil, errors.Wrapf(err, "failed to process block %s", blockHash)
+			return nil, errors.Wrapf(err, "failed to process block %s", blockHash)
 		}
 
 		missingParentsError := &ruleerrors.ErrMissingParents{}
 		if errors.As(err, missingParentsError) {
-			return missingParentsError.MissingParentHashes, nil, nil
+			return missingParentsError.MissingParentHashes, nil
 		}
 		log.Warnf("Rejected block %s from %s: %s", blockHash, flow.peer, err)
-		return nil, nil, protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
+		return nil, protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
 	}
-	return nil, blockInsertionResult, nil
+	return nil, nil
 }
 
 func (flow *handleRelayInvsFlow) relayBlock(block *externalapi.DomainBlock) error {
@@ -245,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
@@ -285,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_block_locator.go

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

app/protocol/flows/blockrelay/handle_request_headers.go

@@ -1,16 +1,16 @@
 package blockrelay
 
 import (
-	"github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
 const ibdBatchSize = router.DefaultMaxMessages
+const maxHeaders = appmessage.MaxInvPerMsg
 
 // RequestIBDBlocksContext is the interface for the context needed for the HandleRequestHeaders flow.
 type RequestIBDBlocksContext interface {
@@ -20,18 +20,14 @@ type RequestIBDBlocksContext interface {
 type handleRequestBlocksFlow struct {
 	RequestIBDBlocksContext
 	incomingRoute, outgoingRoute *router.Route
-	peer                         *peer.Peer
 }
 
 // HandleRequestHeaders handles RequestHeaders messages
-func HandleRequestHeaders(context RequestIBDBlocksContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route, peer *peer.Peer) error {
-
+func HandleRequestHeaders(context RequestIBDBlocksContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
 	flow := &handleRequestBlocksFlow{
 		RequestIBDBlocksContext: context,
 		incomingRoute:           incomingRoute,
 		outgoingRoute:           outgoingRoute,
-		peer:                    peer,
 	}
 	return flow.start()
 }
@@ -42,48 +38,40 @@ func (flow *handleRequestBlocksFlow) start() error {
 		if err != nil {
 			return err
 		}
-		log.Debugf("Recieved requestHeaders with lowHash: %s, highHash: %s", lowHash, highHash)
 
-		for !lowHash.Equal(highHash) {
-			log.Debugf("Getting block headers between %s and %s to %s", lowHash, highHash, flow.peer)
+		msgHeaders, err := flow.buildMsgBlockHeaders(lowHash, highHash)
+		if err != nil {
+			return err
+		}
 
-			// GetHashesBetween is a relatively heavy operation so we limit it
-			// in order to avoid locking the consensus for too long
-			const maxBlueScoreDifference = 1 << 10
-			blockHashes, err := flow.Domain().Consensus().GetHashesBetween(lowHash, highHash, maxBlueScoreDifference)
-			if err != nil {
-				return err
-			}
-			log.Debugf("Got %d header hashes above lowHash %s", len(blockHashes), lowHash)
-
-			blockHeaders := make([]*appmessage.MsgBlockHeader, len(blockHashes))
-			for i, blockHash := range blockHashes {
-				blockHeader, err := flow.Domain().Consensus().GetBlockHeader(blockHash)
-				if err != nil {
-					return err
-				}
-				blockHeaders[i] = appmessage.DomainBlockHeaderToBlockHeader(blockHeader)
+		for offset := 0; offset < len(msgHeaders); offset += ibdBatchSize {
+			end := offset + ibdBatchSize
+			if end > len(msgHeaders) {
+				end = len(msgHeaders)
 			}
 
-			blockHeadersMessage := appmessage.NewBlockHeadersMessage(blockHeaders)
-			err = flow.outgoingRoute.Enqueue(blockHeadersMessage)
+			blocksToSend := msgHeaders[offset:end]
+			err = flow.sendHeaders(blocksToSend)
 			if err != nil {
-				return err
+				return nil
+			}
+
+			// Exit the loop and don't wait for the GetNextIBDBlocks message if the last batch was
+			// less than ibdBatchSize.
+			if len(blocksToSend) < ibdBatchSize {
+				break
 			}
 
 			message, err := flow.incomingRoute.Dequeue()
 			if err != nil {
 				return err
 			}
+
 			if _, ok := message.(*appmessage.MsgRequestNextHeaders); !ok {
 				return protocolerrors.Errorf(true, "received unexpected message type. "+
 					"expected: %s, got: %s", appmessage.CmdRequestNextHeaders, message.Command())
 			}
-
-			// The next lowHash is the last element in blockHashes
-			lowHash = blockHashes[len(blockHashes)-1]
 		}
-
 		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgDoneHeaders())
 		if err != nil {
 			return err
@@ -102,3 +90,37 @@ func receiveRequestHeaders(incomingRoute *router.Route) (lowHash *externalapi.Do
 
 	return msgRequestIBDBlocks.LowHash, msgRequestIBDBlocks.HighHash, nil
 }
+
+func (flow *handleRequestBlocksFlow) buildMsgBlockHeaders(lowHash *externalapi.DomainHash,
+	highHash *externalapi.DomainHash) ([]*appmessage.MsgBlockHeader, error) {
+
+	blockHashes, err := flow.Domain().Consensus().GetHashesBetween(lowHash, highHash)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(blockHashes) > maxHeaders {
+		blockHashes = blockHashes[:maxHeaders]
+	}
+
+	msgBlockHeaders := make([]*appmessage.MsgBlockHeader, len(blockHashes))
+	for i, blockHash := range blockHashes {
+		header, err := flow.Domain().Consensus().GetBlockHeader(blockHash)
+		if err != nil {
+			return nil, err
+		}
+		msgBlockHeaders[i] = appmessage.DomainBlockHeaderToBlockHeader(header)
+	}
+
+	return msgBlockHeaders, nil
+}
+
+func (flow *handleRequestBlocksFlow) sendHeaders(headers []*appmessage.MsgBlockHeader) error {
+	for _, msgBlockHeader := range headers {
+		err := flow.outgoingRoute.Enqueue(msgBlockHeader)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

app/protocol/flows/blockrelay/handle_request_headers_test.go

@@ -0,0 +1,15 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
+	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"testing"
+)
+
+func TestMaxHeaders(t *testing.T) {
+	testutils.ForAllNets(t, false, func(t *testing.T, params *dagconfig.Params) {
+		if params.FinalityDepth() > maxHeaders {
+			t.Errorf("FinalityDepth() in %s should be lower or equal to appmessage.MaxInvPerMsg", params.Name)
+		}
+	})
+}

app/protocol/flows/blockrelay/handle_request_ibd_root_utxo_set_and_block.go

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

app/protocol/flows/blockrelay/handle_request_pruning_point_utxo_set_and_block.go

@@ -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/hashes_queue_set.go

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

app/protocol/flows/blockrelay/ibd.go

@@ -1,13 +1,6 @@
 package blockrelay
 
 import (
-	"fmt"
-	"time"
-
-	"github.com/kaspanet/kaspad/infrastructure/logger"
-
-	"github.com/kaspanet/kaspad/domain/consensus/model"
-
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
@@ -15,10 +8,11 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/pkg/errors"
+	"time"
 )
 
 func (flow *handleRelayInvsFlow) runIBDIfNotRunning(highHash *externalapi.DomainHash) error {
-	wasIBDNotRunning := flow.TrySetIBDRunning(flow.peer)
+	wasIBDNotRunning := flow.TrySetIBDRunning()
 	if !wasIBDNotRunning {
 		log.Debugf("IBD is already running")
 		return nil
@@ -27,24 +21,33 @@ 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)
+	// Fetch all the headers if we don't already have them
+	log.Debugf("Downloading headers up to %s", highHash)
 	err := flow.syncHeaders(highHash)
 	if err != nil {
 		return err
 	}
-	log.Debugf("Finished syncing headers up to %s", highHash)
+	log.Debugf("Finished downloading headers up to %s", highHash)
 
-	log.Debugf("Syncing the current pruning point UTXO set")
-	syncedPruningPointUTXOSetSuccessfully, err := flow.syncPruningPointUTXOSet()
+	// Fetch the UTXO set if we don't already have it
+	log.Debugf("Downloading the IBD root UTXO set under highHash %s", highHash)
+	syncInfo, err := flow.Domain().Consensus().GetSyncInfo()
 	if err != nil {
 		return err
 	}
-	if !syncedPruningPointUTXOSetSuccessfully {
-		log.Debugf("Aborting IBD because the pruning point UTXO set failed to sync")
-		return nil
+	if syncInfo.IsAwaitingUTXOSet {
+		found, err := flow.fetchMissingUTXOSet(syncInfo.IBDRootUTXOBlockHash)
+		if err != nil {
+			return err
+		}
+		if !found {
+			log.Infof("Cannot download the IBD root UTXO set under highHash %s", highHash)
+			return nil
+		}
 	}
-	log.Debugf("Finished syncing the current pruning point UTXO set")
+	log.Debugf("Finished downloading the IBD root UTXO set under highHash %s", highHash)
 
+	// Fetch the block bodies
 	log.Debugf("Downloading block bodies up to %s", highHash)
 	err = flow.syncMissingBlockBodies(highHash)
 	if err != nil {
@@ -56,132 +59,52 @@ func (flow *handleRelayInvsFlow) runIBDIfNotRunning(highHash *externalapi.Domain
 }
 
 func (flow *handleRelayInvsFlow) syncHeaders(highHash *externalapi.DomainHash) error {
-	highHashReceived := false
-	for !highHashReceived {
-		log.Debugf("Trying to find highest shared chain block with peer %s with high hash %s", flow.peer, highHash)
-		highestSharedBlockHash, err := flow.findHighestSharedBlockHash(highHash)
-		if err != nil {
-			return err
-		}
-		log.Debugf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
-
-		err = flow.downloadHeaders(highestSharedBlockHash, highHash)
-		if err != nil {
-			return err
-		}
-
-		// We're finished once highHash has been inserted into the DAG
-		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(highHash)
-		if err != nil {
-			return err
-		}
-		highHashReceived = blockInfo.Exists
-		log.Debugf("Headers downloaded from peer %s. Are further headers required: %t", flow.peer, !highHashReceived)
+	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
 	}
-	return nil
+	log.Debugf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
+
+	return flow.downloadHeaders(highestSharedBlockHash, highHash)
 }
 
-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, err
-	}
+func (flow *handleRelayInvsFlow) findHighestSharedBlockHash(highHash *externalapi.DomainHash) (
+	lowHash *externalapi.DomainHash, err error) {
+
+	lowHash = flow.Config().ActiveNetParams.GenesisHash
+	currentHighHash := highHash
 
 	for {
-		highestHash, err := flow.fetchHighestHash(targetHash, blockLocator)
-		if err != nil {
-			return nil, err
-		}
-		highestHashIndex, err := flow.findHighestHashIndex(highestHash, blockLocator)
+		err := flow.sendGetBlockLocator(lowHash, currentHighHash, 0)
 		if err != nil {
 			return nil, err
 		}
 
-		if highestHashIndex == 0 ||
-			// If the block locator contains only two adjacent chain blocks, the
-			// syncer will always find the same highest chain block, so to avoid
-			// an endless loop, we explicitly stop the loop in such situation.
-			(len(blockLocator) == 2 && highestHashIndex == 1) {
-
-			return highestHash, nil
+		blockLocatorHashes, err := flow.receiveBlockLocator()
+		if err != nil {
+			return nil, err
 		}
 
-		locatorHashAboveHighestHash := highestHash
-		if highestHashIndex > 0 {
-			locatorHashAboveHighestHash = blockLocator[highestHashIndex-1]
+		// We check whether the locator's highest hash is in the local DAG.
+		// If it is, return it. If it isn't, we need to narrow our
+		// getBlockLocator request and try again.
+		locatorHighHash := blockLocatorHashes[0]
+		locatorHighHashInfo, err := flow.Domain().Consensus().GetBlockInfo(locatorHighHash)
+		if err != nil {
+			return nil, err
+		}
+		if locatorHighHashInfo.Exists {
+			return locatorHighHash, nil
 		}
 
-		blockLocator, err = flow.nextBlockLocator(highestHash, locatorHashAboveHighestHash)
+		lowHash, currentHighHash, err = flow.Domain().Consensus().FindNextBlockLocatorBoundaries(blockLocatorHashes)
 		if err != nil {
 			return nil, err
 		}
 	}
 }
 
-func (flow *handleRelayInvsFlow) nextBlockLocator(lowHash, highHash *externalapi.DomainHash) (externalapi.BlockLocator, error) {
-	log.Debugf("Sending a blockLocator to %s between %s and %s", flow.peer, lowHash, highHash)
-	blockLocator, err := flow.Domain().Consensus().CreateHeadersSelectedChainBlockLocator(lowHash, highHash)
-	if err != nil {
-		if errors.Is(model.ErrBlockNotInSelectedParentChain, err) {
-			return nil, err
-		}
-		log.Debugf("Headers selected parent chain moved since findHighestSharedBlockHash - " +
-			"restarting with full block locator")
-		blockLocator, err = flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return blockLocator, nil
-}
-
-func (flow *handleRelayInvsFlow) findHighestHashIndex(
-	highestHash *externalapi.DomainHash, blockLocator externalapi.BlockLocator) (int, error) {
-
-	highestHashIndex := 0
-	highestHashIndexFound := false
-	for i, blockLocatorHash := range blockLocator {
-		if highestHash.Equal(blockLocatorHash) {
-			highestHashIndex = i
-			highestHashIndexFound = true
-			break
-		}
-	}
-	if !highestHashIndexFound {
-		return 0, protocolerrors.Errorf(true, "highest hash %s "+
-			"returned from peer %s is not in the original blockLocator", highestHash, flow.peer)
-	}
-	log.Debugf("The index of the highest hash in the original "+
-		"blockLocator sent to %s is %d", flow.peer, highestHashIndex)
-
-	return highestHashIndex, nil
-}
-
-func (flow *handleRelayInvsFlow) fetchHighestHash(
-	targetHash *externalapi.DomainHash, blockLocator externalapi.BlockLocator) (*externalapi.DomainHash, error) {
-
-	ibdBlockLocatorMessage := appmessage.NewMsgIBDBlockLocator(targetHash, blockLocator)
-	err := flow.outgoingRoute.Enqueue(ibdBlockLocatorMessage)
-	if err != nil {
-		return nil, err
-	}
-	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
-	if err != nil {
-		return nil, err
-	}
-	ibdBlockLocatorHighestHashMessage, ok := message.(*appmessage.MsgIBDBlockLocatorHighestHash)
-	if !ok {
-		return nil, protocolerrors.Errorf(true, "received unexpected message type. "+
-			"expected: %s, got: %s", appmessage.CmdIBDBlockLocatorHighestHash, message.Command())
-	}
-	highestHash := ibdBlockLocatorHighestHashMessage.HighestHash
-	log.Debugf("The highest hash the peer %s knows is %s", flow.peer, highestHash)
-
-	return highestHash, nil
-}
-
 func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externalapi.DomainHash,
 	highHash *externalapi.DomainHash) error {
 
@@ -190,48 +113,28 @@ func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externa
 		return err
 	}
 
-	// Keep a short queue of blockHeadersMessages so that there's
-	// never a moment when the node is not validating and inserting
-	// 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()
-			if err != nil {
-				errChan <- err
-				return
-			}
-			if doneIBD {
-				doneChan <- struct{}{}
-				return
-			}
+	blocksReceived := 0
+	for {
+		msgBlockHeader, doneIBD, err := flow.receiveHeader()
+		if err != nil {
+			return err
+		}
+		if doneIBD {
+			return nil
+		}
 
-			blockHeadersMessageChan <- blockHeadersMessage
+		err = flow.processHeader(msgBlockHeader)
+		if err != nil {
+			return err
+		}
 
+		blocksReceived++
+		if blocksReceived%ibdBatchSize == 0 {
 			err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestNextHeaders())
 			if err != nil {
-				errChan <- err
-				return
+				return err
 			}
 		}
-	})
-
-	for {
-		select {
-		case blockHeadersMessage := <-blockHeadersMessageChan:
-			for _, header := range blockHeadersMessage.BlockHeaders {
-				err = flow.processHeader(header)
-				if err != nil {
-					return err
-				}
-			}
-		case err := <-errChan:
-			return err
-		case <-doneChan:
-			return nil
-		}
 	}
 }
 
@@ -242,13 +145,13 @@ func (flow *handleRelayInvsFlow) sendRequestHeaders(highestSharedBlockHash *exte
 	return flow.outgoingRoute.Enqueue(msgGetBlockInvs)
 }
 
-func (flow *handleRelayInvsFlow) receiveHeaders() (msgIBDBlock *appmessage.BlockHeadersMessage, doneIBD bool, err error) {
+func (flow *handleRelayInvsFlow) receiveHeader() (msgIBDBlock *appmessage.MsgBlockHeader, doneIBD bool, err error) {
 	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
 	if err != nil {
 		return nil, false, err
 	}
 	switch message := message.(type) {
-	case *appmessage.BlockHeadersMessage:
+	case *appmessage.MsgBlockHeader:
 		return message, false, nil
 	case *appmessage.MsgDoneHeaders:
 		return nil, true, nil
@@ -280,186 +183,66 @@ 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
 }
 
-func (flow *handleRelayInvsFlow) syncPruningPointUTXOSet() (bool, error) {
-	log.Debugf("Checking if a new pruning point is available")
-	err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestPruningPointHashMessage())
-	if err != nil {
-		return false, err
-	}
-	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
-	if err != nil {
-		return false, err
-	}
-	msgPruningPointHash, ok := message.(*appmessage.MsgPruningPointHashMessage)
-	if !ok {
-		return false, protocolerrors.Errorf(true, "received unexpected message type. "+
-			"expected: %s, got: %s", appmessage.CmdPruningPointHash, message.Command())
-	}
-
-	blockInfo, err := flow.Domain().Consensus().GetBlockInfo(msgPruningPointHash.Hash)
+func (flow *handleRelayInvsFlow) fetchMissingUTXOSet(ibdRootHash *externalapi.DomainHash) (succeed bool, err error) {
+	err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDRootUTXOSetAndBlock(ibdRootHash))
 	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)
-		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)
+	utxoSet, block, found, err := flow.receiveIBDRootUTXOSetAndBlock()
 	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)
+	if !found {
 		return false, nil
 	}
 
-	log.Info("Fetching the pruning point UTXO set")
-	succeed, err := flow.fetchMissingUTXOSet(msgPruningPointHash.Hash)
+	err = flow.Domain().Consensus().ValidateAndInsertPruningPoint(block, utxoSet)
+	if err != nil {
+		return false, protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "error with IBD root UTXO set")
+	}
+
+	syncInfo, err := flow.Domain().Consensus().GetSyncInfo()
 	if err != nil {
 		return false, err
 	}
 
-	if !succeed {
-		log.Infof("Couldn't successfully fetch the pruning point UTXO set. Stopping IBD.")
+	// TODO: Find a better way to deal with finality conflicts.
+	if syncInfo.IsAwaitingUTXOSet {
+		log.Warnf("Still awaiting for UTXO set. This can happen only because the given pruning point violates " +
+			"finality. If this keeps happening delete the data directory and restart your node.")
 		return false, nil
 	}
 
-	log.Info("Fetched the new pruning point UTXO set")
-	return true, nil
-}
-
-func (flow *handleRelayInvsFlow) fetchMissingUTXOSet(pruningPointHash *externalapi.DomainHash) (succeed bool, err error) {
-	defer func() {
-		err := flow.Domain().Consensus().ClearImportedPruningPointData()
-		if err != nil {
-			panic(fmt.Sprintf("failed to clear imported pruning point data: %s", err))
-		}
-	}()
-
-	err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestPruningPointUTXOSetAndBlock(pruningPointHash))
-	if err != nil {
-		return false, err
-	}
-
-	block, err := flow.receivePruningPointBlock()
-	if err != nil {
-		return false, err
-	}
-
-	receivedAll, err := flow.receiveAndInsertPruningPointUTXOSet(pruningPointHash)
-	if err != nil {
-		return false, err
-	}
-	if !receivedAll {
-		return false, nil
-	}
-
-	err = flow.Domain().Consensus().ValidateAndInsertImportedPruningPoint(block)
-	if err != nil {
-		// TODO: Find a better way to deal with finality conflicts.
-		if errors.Is(err, ruleerrors.ErrSuggestedPruningViolatesFinality) {
-			return false, nil
-		}
-		return false, protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "error with pruning point UTXO set")
-	}
-
 	return true, nil
 }
 
-func (flow *handleRelayInvsFlow) receivePruningPointBlock() (*externalapi.DomainBlock, error) {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "receivePruningPointBlock")
-	defer onEnd()
-
+func (flow *handleRelayInvsFlow) receiveIBDRootUTXOSetAndBlock() ([]byte, *externalapi.DomainBlock, bool, error) {
 	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())
-	}
-	block := appmessage.MsgBlockToDomainBlock(ibdBlockMessage.MsgBlock)
-
-	log.Debugf("Received pruning point block %s", consensushashing.BlockHash(block))
-
-	return block, nil
-}
-
-func (flow *handleRelayInvsFlow) receiveAndInsertPruningPointUTXOSet(
-	pruningPointHash *externalapi.DomainHash) (bool, error) {
-
-	onEnd := logger.LogAndMeasureExecutionTime(log, "receiveAndInsertPruningPointUTXOSet")
-	defer onEnd()
-
-	receivedChunkCount := 0
-	receivedUTXOCount := 0
-	for {
-		message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
-		if err != nil {
-			return false, err
-		}
-
-		switch message := message.(type) {
-		case *appmessage.MsgPruningPointUTXOSetChunk:
-			receivedUTXOCount += len(message.OutpointAndUTXOEntryPairs)
-			domainOutpointAndUTXOEntryPairs :=
-				appmessage.OutpointAndUTXOEntryPairsToDomainOutpointAndUTXOEntryPairs(message.OutpointAndUTXOEntryPairs)
-
-			err := flow.Domain().Consensus().AppendImportedPruningPointUTXOs(domainOutpointAndUTXOEntryPairs)
-			if err != nil {
-				return false, err
-			}
-
-			receivedChunkCount++
-			if receivedChunkCount%ibdBatchSize == 0 {
-				log.Debugf("Received %d UTXO set chunks so far, totaling in %d UTXOs",
-					receivedChunkCount, receivedUTXOCount)
-
-				requestNextPruningPointUTXOSetChunkMessage := appmessage.NewMsgRequestNextPruningPointUTXOSetChunk()
-				err := flow.outgoingRoute.Enqueue(requestNextPruningPointUTXOSetChunkMessage)
-				if err != nil {
-					return false, err
-				}
-			}
-
-		case *appmessage.MsgDonePruningPointUTXOSetChunks:
-			log.Infof("Finished receiving the UTXO set. Total UTXOs: %d", receivedUTXOCount)
-			return true, nil
-
-		case *appmessage.MsgUnexpectedPruningPoint:
-			log.Infof("Could not receive the next UTXO chunk because the pruning point %s "+
-				"is no longer the pruning point of peer %s", pruningPointHash, flow.peer)
-			return false, nil
-
-		default:
-			return false, protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s or %s or %s, got: %s", appmessage.CmdPruningPointUTXOSetChunk,
-				appmessage.CmdDonePruningPointUTXOSetChunks, appmessage.CmdUnexpectedPruningPoint, message.Command(),
+	switch message := message.(type) {
+	case *appmessage.MsgIBDRootUTXOSetAndBlock:
+		return message.UTXOSet,
+			appmessage.MsgBlockToDomainBlock(message.Block), true, nil
+	case *appmessage.MsgIBDRootNotFound:
+		return nil, nil, false, nil
+	default:
+		return nil, nil, false,
+			protocolerrors.Errorf(true, "received unexpected message type. "+
+				"expected: %s or %s, got: %s",
+				appmessage.CmdIBDRootUTXOSetAndBlock, appmessage.CmdIBDRootNotFound, message.Command(),
 			)
-		}
 	}
 }
 
@@ -496,19 +279,15 @@ func (flow *handleRelayInvsFlow) syncMissingBlockBodies(highHash *externalapi.Do
 
 			block := appmessage.MsgBlockToDomainBlock(msgIBDBlock.MsgBlock)
 			blockHash := consensushashing.BlockHash(block)
-			if !expectedHash.Equal(blockHash) {
+			if *expectedHash != *blockHash {
 				return protocolerrors.Errorf(true, "expected block %s but got %s", expectedHash, blockHash)
 			}
 
-			blockInsertionResult, err := flow.Domain().Consensus().ValidateAndInsertBlock(block)
+			_, 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)
+			err = flow.OnNewBlock(block)
 			if err != nil {
 				return err
 			}

app/protocol/flows/handshake/handshake.go

@@ -82,7 +82,7 @@ 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

app/protocol/flows/handshake/receiveversion.go

@@ -42,11 +42,9 @@ func ReceiveVersion(context HandleHandshakeContext, incomingRoute *router.Route,
 }
 
 func (flow *receiveVersionFlow) start() (*appmessage.NetAddress, error) {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "receiveVersionFlow.start")
+	onEnd := logger.LogAndMeasureExecutionTime(log, "receiveVersionFlow.start()")
 	defer onEnd()
 
-	log.Debugf("Starting receiveVersionFlow with %s", flow.peer.Address())
-
 	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
 	if err != nil {
 		return nil, err
@@ -60,7 +58,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
@@ -92,7 +90,7 @@ func (flow *receiveVersionFlow) start() (*appmessage.NetAddress, error) {
 	isRemoteNodeFull := msgVersion.SubnetworkID == nil
 	isOutbound := flow.peer.Connection().IsOutbound()
 	if (isLocalNodeFull && !isRemoteNodeFull && isOutbound) ||
-		(!isLocalNodeFull && !isRemoteNodeFull && !msgVersion.SubnetworkID.Equal(localSubnetworkID)) {
+		(!isLocalNodeFull && !isRemoteNodeFull && *msgVersion.SubnetworkID != *localSubnetworkID) {
 
 		return nil, protocolerrors.New(false, "incompatible subnetworks")
 	}

app/protocol/flows/handshake/sendversion.go

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

app/protocol/flows/testing/common_test.go

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

app/protocol/flows/testing/receiveaddresses_test.go

@@ -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/transactionrelay/handle_relayed_transactions.go

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

app/protocol/manager.go

@@ -37,12 +37,6 @@ func (m *Manager) Peers() []*peerpkg.Peer {
 	return m.context.Peers()
 }
 
-// IBDPeer returns the current IBD peer or null if the node is not
-// in IBD
-func (m *Manager) IBDPeer() *peerpkg.Peer {
-	return m.context.IBDPeer()
-}
-
 // AddTransaction adds transaction to the mempool and propagates it.
 func (m *Manager) AddTransaction(tx *externalapi.DomainTransaction) error {
 	return m.context.AddTransaction(tx)
@@ -73,14 +67,3 @@ func (m *Manager) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler flowconte
 func (m *Manager) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler flowcontext.OnTransactionAddedToMempoolHandler) {
 	m.context.SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler)
 }
-
-// ShouldMine returns whether it's ok to use block template from this node
-// for mining purposes.
-func (m *Manager) ShouldMine() (bool, error) {
-	return m.context.ShouldMine()
-}
-
-// IsIBDRunning returns true if IBD is currently marked as running
-func (m *Manager) IsIBDRunning() bool {
-	return m.context.IsIBDRunning()
-}

app/protocol/protocol.go

@@ -44,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
 		}
@@ -78,13 +77,16 @@ func (m *Manager) handleError(err error, netConnection *netadapter.NetConnection
 		if !m.context.Config().DisableBanning && protocolErr.ShouldBan {
 			log.Warnf("Banning %s (reason: %s)", netConnection, protocolErr.Cause)
 
-			m.context.ConnectionManager().Ban(netConnection)
+			err := m.context.ConnectionManager().Ban(netConnection)
+			if err != nil && !errors.Is(err, addressmanager.ErrAddressNotFound) {
+				panic(err)
+			}
+
 			err = outgoingRoute.Enqueue(appmessage.NewMsgReject(protocolErr.Error()))
 			if err != nil && !errors.Is(err, routerpkg.ErrRouteClosed) {
 				panic(err)
 			}
 		}
-		log.Debugf("Disconnecting from %s (reason: %s)", netConnection, protocolErr.Cause)
 		netConnection.Disconnect()
 		return
 	}
@@ -133,10 +135,9 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 	return []*flow{
 		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.CmdDonePruningPointUTXOSetChunks},
-			isStopping, errChan, func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
+			appmessage.CmdDoneHeaders, appmessage.CmdIBDRootNotFound, appmessage.CmdIBDRootUTXOSetAndBlock,
+			appmessage.CmdHeader}, isStopping, errChan,
+			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
 				return blockrelay.HandleRelayInvs(m.context, incomingRoute,
 					outgoingRoute, peer)
 			},
@@ -158,15 +159,14 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 		m.registerFlow("HandleRequestHeaders", router,
 			[]appmessage.MessageCommand{appmessage.CmdRequestHeaders, appmessage.CmdRequestNextHeaders}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRequestHeaders(m.context, incomingRoute, outgoingRoute, peer)
+				return blockrelay.HandleRequestHeaders(m.context, incomingRoute, outgoingRoute)
 			},
 		),
 
-		m.registerFlow("HandleRequestPruningPointUTXOSetAndBlock", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointUTXOSetAndBlock,
-				appmessage.CmdRequestNextPruningPointUTXOSetChunk}, isStopping, errChan,
+		m.registerFlow("HandleRequestIBDRootUTXOSetAndBlock", router,
+			[]appmessage.MessageCommand{appmessage.CmdRequestIBDRootUTXOSetAndBlock}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRequestPruningPointUTXOSetAndBlock(m.context, incomingRoute, outgoingRoute)
+				return blockrelay.HandleRequestIBDRootUTXOSetAndBlock(m.context, incomingRoute, outgoingRoute)
 			},
 		),
 
@@ -176,20 +176,6 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 				return blockrelay.HandleIBDBlockRequests(m.context, incomingRoute, outgoingRoute)
 			},
 		),
-
-		m.registerFlow("HandlePruningPointHashRequests", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestPruningPointHash}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandlePruningPointHashRequests(m.context, incomingRoute, outgoingRoute)
-			},
-		),
-
-		m.registerFlow("HandleIBDBlockLocator", router,
-			[]appmessage.MessageCommand{appmessage.CmdIBDBlockLocator}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleIBDBlockLocator(m.context, incomingRoute, outgoingRoute, peer)
-			},
-		),
 	}
 }
 

app/protocol/protocolerrors/protocolerrors.go

@@ -16,7 +16,6 @@ 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 {
 	return e.Cause
 }

app/rpc/manager.go

@@ -6,9 +6,7 @@ import (
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
 	"github.com/kaspanet/kaspad/domain"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/utxoindex"
 	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/logger"
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
@@ -27,7 +25,6 @@ func NewManager(
 	protocolManager *protocol.Manager,
 	connectionManager *connmanager.ConnectionManager,
 	addressManager *addressmanager.AddressManager,
-	utxoIndex *utxoindex.UTXOIndex,
 	shutDownChan chan<- struct{}) *Manager {
 
 	manager := Manager{
@@ -38,7 +35,6 @@ func NewManager(
 			protocolManager,
 			connectionManager,
 			addressManager,
-			utxoIndex,
 			shutDownChan,
 		),
 	}
@@ -48,86 +44,19 @@ func NewManager(
 }
 
 // NotifyBlockAddedToDAG notifies the manager that a block has been added to the DAG
-func (m *Manager) NotifyBlockAddedToDAG(block *externalapi.DomainBlock, blockInsertionResult *externalapi.BlockInsertionResult) error {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyBlockAddedToDAG")
-	defer onEnd()
-
-	if m.context.Config.UTXOIndex {
-		err := m.notifyUTXOsChanged(blockInsertionResult)
-		if err != nil {
-			return err
-		}
-	}
-
-	err := m.notifyVirtualSelectedParentBlueScoreChanged()
-	if err != nil {
-		return err
-	}
-
-	err = m.notifyVirtualSelectedParentChainChanged(blockInsertionResult)
-	if err != nil {
-		return err
-	}
-
-	blockAddedNotification := appmessage.NewBlockAddedNotificationMessage(appmessage.DomainBlockToMsgBlock(block))
-	return m.context.NotificationManager.NotifyBlockAdded(blockAddedNotification)
+func (m *Manager) NotifyBlockAddedToDAG(block *externalapi.DomainBlock) error {
+	notification := appmessage.NewBlockAddedNotificationMessage(appmessage.DomainBlockToMsgBlock(block))
+	return m.context.NotificationManager.NotifyBlockAdded(notification)
 }
 
 // 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")
-	defer onEnd()
-
 	notification := appmessage.NewFinalityConflictNotificationMessage(violatingBlockHash)
 	return m.context.NotificationManager.NotifyFinalityConflict(notification)
 }
 
 // NotifyFinalityConflictResolved notifies the manager that a finality conflict in the DAG has been resolved
 func (m *Manager) NotifyFinalityConflictResolved(finalityBlockHash string) error {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyFinalityConflictResolved")
-	defer onEnd()
-
 	notification := appmessage.NewFinalityConflictResolvedNotificationMessage(finalityBlockHash)
 	return m.context.NotificationManager.NotifyFinalityConflictResolved(notification)
 }
-
-func (m *Manager) notifyUTXOsChanged(blockInsertionResult *externalapi.BlockInsertionResult) error {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyUTXOsChanged")
-	defer onEnd()
-
-	utxoIndexChanges, err := m.context.UTXOIndex.Update(blockInsertionResult.VirtualSelectedParentChainChanges)
-	if err != nil {
-		return err
-	}
-	return m.context.NotificationManager.NotifyUTXOsChanged(utxoIndexChanges)
-}
-
-func (m *Manager) notifyVirtualSelectedParentBlueScoreChanged() error {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualSelectedParentBlueScoreChanged")
-	defer onEnd()
-
-	virtualSelectedParent, err := m.context.Domain.Consensus().GetVirtualSelectedParent()
-	if err != nil {
-		return err
-	}
-
-	blockInfo, err := m.context.Domain.Consensus().GetBlockInfo(virtualSelectedParent)
-	if err != nil {
-		return err
-	}
-
-	notification := appmessage.NewVirtualSelectedParentBlueScoreChangedNotificationMessage(blockInfo.BlueScore)
-	return m.context.NotificationManager.NotifyVirtualSelectedParentBlueScoreChanged(notification)
-}
-
-func (m *Manager) notifyVirtualSelectedParentChainChanged(blockInsertionResult *externalapi.BlockInsertionResult) error {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualSelectedParentChainChanged")
-	defer onEnd()
-
-	notification, err := m.context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
-		blockInsertionResult.VirtualSelectedParentChainChanges)
-	if err != nil {
-		return err
-	}
-	return m.context.NotificationManager.NotifyVirtualSelectedParentChainChanged(notification)
-}

app/rpc/rpc.go

@@ -12,32 +12,28 @@ import (
 type handler func(context *rpccontext.Context, router *router.Router, request appmessage.Message) (appmessage.Message, error)
 
 var handlers = map[appmessage.MessageCommand]handler{
-	appmessage.CmdGetCurrentNetworkRequestMessage:                           rpchandlers.HandleGetCurrentNetwork,
-	appmessage.CmdSubmitBlockRequestMessage:                                 rpchandlers.HandleSubmitBlock,
-	appmessage.CmdGetBlockTemplateRequestMessage:                            rpchandlers.HandleGetBlockTemplate,
-	appmessage.CmdNotifyBlockAddedRequestMessage:                            rpchandlers.HandleNotifyBlockAdded,
-	appmessage.CmdGetPeerAddressesRequestMessage:                            rpchandlers.HandleGetPeerAddresses,
-	appmessage.CmdGetSelectedTipHashRequestMessage:                          rpchandlers.HandleGetSelectedTipHash,
-	appmessage.CmdGetMempoolEntryRequestMessage:                             rpchandlers.HandleGetMempoolEntry,
-	appmessage.CmdGetConnectedPeerInfoRequestMessage:                        rpchandlers.HandleGetConnectedPeerInfo,
-	appmessage.CmdAddPeerRequestMessage:                                     rpchandlers.HandleAddPeer,
-	appmessage.CmdSubmitTransactionRequestMessage:                           rpchandlers.HandleSubmitTransaction,
-	appmessage.CmdNotifyVirtualSelectedParentChainChangedRequestMessage:     rpchandlers.HandleNotifyVirtualSelectedParentChainChanged,
-	appmessage.CmdGetBlockRequestMessage:                                    rpchandlers.HandleGetBlock,
-	appmessage.CmdGetSubnetworkRequestMessage:                               rpchandlers.HandleGetSubnetwork,
-	appmessage.CmdGetVirtualSelectedParentChainFromBlockRequestMessage:      rpchandlers.HandleGetVirtualSelectedParentChainFromBlock,
-	appmessage.CmdGetBlocksRequestMessage:                                   rpchandlers.HandleGetBlocks,
-	appmessage.CmdGetBlockCountRequestMessage:                               rpchandlers.HandleGetBlockCount,
-	appmessage.CmdGetBlockDAGInfoRequestMessage:                             rpchandlers.HandleGetBlockDAGInfo,
-	appmessage.CmdResolveFinalityConflictRequestMessage:                     rpchandlers.HandleResolveFinalityConflict,
-	appmessage.CmdNotifyFinalityConflictsRequestMessage:                     rpchandlers.HandleNotifyFinalityConflicts,
-	appmessage.CmdGetMempoolEntriesRequestMessage:                           rpchandlers.HandleGetMempoolEntries,
-	appmessage.CmdShutDownRequestMessage:                                    rpchandlers.HandleShutDown,
-	appmessage.CmdGetHeadersRequestMessage:                                  rpchandlers.HandleGetHeaders,
-	appmessage.CmdNotifyUTXOsChangedRequestMessage:                          rpchandlers.HandleNotifyUTXOsChanged,
-	appmessage.CmdGetUTXOsByAddressesRequestMessage:                         rpchandlers.HandleGetUTXOsByAddresses,
-	appmessage.CmdGetVirtualSelectedParentBlueScoreRequestMessage:           rpchandlers.HandleGetVirtualSelectedParentBlueScore,
-	appmessage.CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage: rpchandlers.HandleNotifyVirtualSelectedParentBlueScoreChanged,
+	appmessage.CmdGetCurrentNetworkRequestMessage:       rpchandlers.HandleGetCurrentNetwork,
+	appmessage.CmdSubmitBlockRequestMessage:             rpchandlers.HandleSubmitBlock,
+	appmessage.CmdGetBlockTemplateRequestMessage:        rpchandlers.HandleGetBlockTemplate,
+	appmessage.CmdNotifyBlockAddedRequestMessage:        rpchandlers.HandleNotifyBlockAdded,
+	appmessage.CmdGetPeerAddressesRequestMessage:        rpchandlers.HandleGetPeerAddresses,
+	appmessage.CmdGetSelectedTipHashRequestMessage:      rpchandlers.HandleGetSelectedTipHash,
+	appmessage.CmdGetMempoolEntryRequestMessage:         rpchandlers.HandleGetMempoolEntry,
+	appmessage.CmdGetConnectedPeerInfoRequestMessage:    rpchandlers.HandleGetConnectedPeerInfo,
+	appmessage.CmdAddPeerRequestMessage:                 rpchandlers.HandleAddPeer,
+	appmessage.CmdSubmitTransactionRequestMessage:       rpchandlers.HandleSubmitTransaction,
+	appmessage.CmdNotifyChainChangedRequestMessage:      rpchandlers.HandleNotifyChainChanged,
+	appmessage.CmdGetBlockRequestMessage:                rpchandlers.HandleGetBlock,
+	appmessage.CmdGetSubnetworkRequestMessage:           rpchandlers.HandleGetSubnetwork,
+	appmessage.CmdGetChainFromBlockRequestMessage:       rpchandlers.HandleGetChainFromBlock,
+	appmessage.CmdGetBlocksRequestMessage:               rpchandlers.HandleGetBlocks,
+	appmessage.CmdGetBlockCountRequestMessage:           rpchandlers.HandleGetBlockCount,
+	appmessage.CmdGetBlockDAGInfoRequestMessage:         rpchandlers.HandleGetBlockDAGInfo,
+	appmessage.CmdResolveFinalityConflictRequestMessage: rpchandlers.HandleResolveFinalityConflict,
+	appmessage.CmdNotifyFinalityConflictsRequestMessage: rpchandlers.HandleNotifyFinalityConflicts,
+	appmessage.CmdGetMempoolEntriesRequestMessage:       rpchandlers.HandleGetMempoolEntries,
+	appmessage.CmdShutDownRequestMessage:                rpchandlers.HandleShutDown,
+	appmessage.CmdGetHeadersRequestMessage:              rpchandlers.HandleGetHeaders,
 }
 
 func (m *Manager) routerInitializer(router *router.Router, netConnection *netadapter.NetConnection) {

app/rpc/rpccontext/chain_changed.go

@@ -1,45 +0,0 @@
-package rpccontext
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-)
-
-// ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage converts
-// VirtualSelectedParentChainChanges to VirtualSelectedParentChainChangedNotificationMessage
-func (ctx *Context) ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
-	selectedParentChainChanges *externalapi.SelectedChainPath) (*appmessage.VirtualSelectedParentChainChangedNotificationMessage, error) {
-
-	removedChainBlockHashes := make([]string, len(selectedParentChainChanges.Removed))
-	for i, removed := range selectedParentChainChanges.Removed {
-		removedChainBlockHashes[i] = removed.String()
-	}
-
-	addedChainBlocks := make([]*appmessage.ChainBlock, len(selectedParentChainChanges.Added))
-	for i, added := range selectedParentChainChanges.Added {
-		acceptanceData, err := ctx.Domain.Consensus().GetBlockAcceptanceData(added)
-		if err != nil {
-			return nil, err
-		}
-		acceptedBlocks := make([]*appmessage.AcceptedBlock, len(acceptanceData))
-		for j, acceptedBlock := range acceptanceData {
-			acceptedTransactionIDs := make([]string, len(acceptedBlock.TransactionAcceptanceData))
-			for k, transaction := range acceptedBlock.TransactionAcceptanceData {
-				transactionID := consensushashing.TransactionID(transaction.Transaction)
-				acceptedTransactionIDs[k] = transactionID.String()
-			}
-			acceptedBlocks[j] = &appmessage.AcceptedBlock{
-				Hash:                   acceptedBlock.BlockHash.String(),
-				AcceptedTransactionIDs: acceptedTransactionIDs,
-			}
-		}
-
-		addedChainBlocks[i] = &appmessage.ChainBlock{
-			Hash:           added.String(),
-			AcceptedBlocks: acceptedBlocks,
-		}
-	}
-
-	return appmessage.NewVirtualSelectedParentChainChangedNotificationMessage(removedChainBlockHashes, addedChainBlocks), nil
-}

app/rpc/rpccontext/context.go

@@ -3,7 +3,6 @@ package rpccontext
 import (
 	"github.com/kaspanet/kaspad/app/protocol"
 	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/utxoindex"
 	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
@@ -18,7 +17,6 @@ type Context struct {
 	ProtocolManager   *protocol.Manager
 	ConnectionManager *connmanager.ConnectionManager
 	AddressManager    *addressmanager.AddressManager
-	UTXOIndex         *utxoindex.UTXOIndex
 	ShutDownChan      chan<- struct{}
 
 	NotificationManager *NotificationManager
@@ -31,7 +29,6 @@ func NewContext(cfg *config.Config,
 	protocolManager *protocol.Manager,
 	connectionManager *connmanager.ConnectionManager,
 	addressManager *addressmanager.AddressManager,
-	utxoIndex *utxoindex.UTXOIndex,
 	shutDownChan chan<- struct{}) *Context {
 
 	context := &Context{
@@ -41,10 +38,8 @@ func NewContext(cfg *config.Config,
 		ProtocolManager:   protocolManager,
 		ConnectionManager: connectionManager,
 		AddressManager:    addressManager,
-		UTXOIndex:         utxoIndex,
 		ShutDownChan:      shutDownChan,
 	}
 	context.NotificationManager = NewNotificationManager()
-
 	return context
 }

app/rpc/rpccontext/notificationmanager.go

@@ -1,12 +1,10 @@
 package rpccontext
 
 import (
-	"sync"
-
 	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/utxoindex"
 	routerpkg "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/pkg/errors"
+	"sync"
 )
 
 // NotificationManager manages notifications for the RPC
@@ -15,23 +13,12 @@ type NotificationManager struct {
 	listeners map[*routerpkg.Router]*NotificationListener
 }
 
-// UTXOsChangedNotificationAddress represents a kaspad address.
-// This type is meant to be used in UTXOsChanged notifications
-type UTXOsChangedNotificationAddress struct {
-	Address               string
-	ScriptPublicKeyString utxoindex.ScriptPublicKeyString
-}
-
 // NotificationListener represents a registered RPC notification listener
 type NotificationListener struct {
-	propagateBlockAddedNotifications                            bool
-	propagateVirtualSelectedParentChainChangedNotifications     bool
-	propagateFinalityConflictNotifications                      bool
-	propagateFinalityConflictResolvedNotifications              bool
-	propagateUTXOsChangedNotifications                          bool
-	propagateVirtualSelectedParentBlueScoreChangedNotifications bool
-
-	propagateUTXOsChangedNotificationAddresses []*UTXOsChangedNotificationAddress
+	propagateBlockAddedNotifications               bool
+	propagateChainChangedNotifications             bool
+	propagateFinalityConflictNotifications         bool
+	propagateFinalityConflictResolvedNotifications bool
 }
 
 // NewNotificationManager creates a new NotificationManager
@@ -88,13 +75,13 @@ func (nm *NotificationManager) NotifyBlockAdded(notification *appmessage.BlockAd
 	return nil
 }
 
-// NotifyVirtualSelectedParentChainChanged notifies the notification manager that the DAG's selected parent chain has changed
-func (nm *NotificationManager) NotifyVirtualSelectedParentChainChanged(notification *appmessage.VirtualSelectedParentChainChangedNotificationMessage) error {
+// NotifyChainChanged notifies the notification manager that the DAG's selected parent chain has changed
+func (nm *NotificationManager) NotifyChainChanged(notification *appmessage.ChainChangedNotificationMessage) error {
 	nm.RLock()
 	defer nm.RUnlock()
 
 	for router, listener := range nm.listeners {
-		if listener.propagateVirtualSelectedParentChainChangedNotifications {
+		if listener.propagateChainChangedNotifications {
 			err := router.OutgoingRoute().Enqueue(notification)
 			if err != nil {
 				return err
@@ -136,58 +123,12 @@ func (nm *NotificationManager) NotifyFinalityConflictResolved(notification *appm
 	return nil
 }
 
-// NotifyUTXOsChanged notifies the notification manager that UTXOs have been changed
-func (nm *NotificationManager) NotifyUTXOsChanged(utxoChanges *utxoindex.UTXOChanges) error {
-	nm.RLock()
-	defer nm.RUnlock()
-
-	for router, listener := range nm.listeners {
-		if listener.propagateUTXOsChangedNotifications {
-			// Filter utxoChanges and create a notification
-			notification := listener.convertUTXOChangesToUTXOsChangedNotification(utxoChanges)
-
-			// Don't send the notification if it's empty
-			if len(notification.Added) == 0 && len(notification.Removed) == 0 {
-				continue
-			}
-
-			// Enqueue the notification
-			err := router.OutgoingRoute().Enqueue(notification)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// NotifyVirtualSelectedParentBlueScoreChanged notifies the notification manager that the DAG's
-// virtual selected parent blue score has changed
-func (nm *NotificationManager) NotifyVirtualSelectedParentBlueScoreChanged(
-	notification *appmessage.VirtualSelectedParentBlueScoreChangedNotificationMessage) error {
-
-	nm.RLock()
-	defer nm.RUnlock()
-
-	for router, listener := range nm.listeners {
-		if listener.propagateVirtualSelectedParentBlueScoreChangedNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
 func newNotificationListener() *NotificationListener {
 	return &NotificationListener{
-		propagateBlockAddedNotifications:                            false,
-		propagateVirtualSelectedParentChainChangedNotifications:     false,
-		propagateFinalityConflictNotifications:                      false,
-		propagateFinalityConflictResolvedNotifications:              false,
-		propagateUTXOsChangedNotifications:                          false,
-		propagateVirtualSelectedParentBlueScoreChangedNotifications: false,
+		propagateBlockAddedNotifications:               false,
+		propagateChainChangedNotifications:             false,
+		propagateFinalityConflictNotifications:         false,
+		propagateFinalityConflictResolvedNotifications: false,
 	}
 }
 
@@ -197,10 +138,10 @@ func (nl *NotificationListener) PropagateBlockAddedNotifications() {
 	nl.propagateBlockAddedNotifications = true
 }
 
-// PropagateVirtualSelectedParentChainChangedNotifications instructs the listener to send chain changed notifications
+// PropagateChainChangedNotifications instructs the listener to send chain changed notifications
 // to the remote listener
-func (nl *NotificationListener) PropagateVirtualSelectedParentChainChangedNotifications() {
-	nl.propagateVirtualSelectedParentChainChangedNotifications = true
+func (nl *NotificationListener) PropagateChainChangedNotifications() {
+	nl.propagateChainChangedNotifications = true
 }
 
 // PropagateFinalityConflictNotifications instructs the listener to send finality conflict notifications
@@ -214,41 +155,3 @@ func (nl *NotificationListener) PropagateFinalityConflictNotifications() {
 func (nl *NotificationListener) PropagateFinalityConflictResolvedNotifications() {
 	nl.propagateFinalityConflictResolvedNotifications = true
 }
-
-// PropagateUTXOsChangedNotifications instructs the listener to send UTXOs changed notifications
-// to the remote listener
-func (nl *NotificationListener) PropagateUTXOsChangedNotifications(addresses []*UTXOsChangedNotificationAddress) {
-	nl.propagateUTXOsChangedNotifications = true
-	nl.propagateUTXOsChangedNotificationAddresses = addresses
-}
-
-func (nl *NotificationListener) convertUTXOChangesToUTXOsChangedNotification(
-	utxoChanges *utxoindex.UTXOChanges) *appmessage.UTXOsChangedNotificationMessage {
-
-	notification := &appmessage.UTXOsChangedNotificationMessage{}
-	for _, listenerAddress := range nl.propagateUTXOsChangedNotificationAddresses {
-		listenerScriptPublicKeyString := listenerAddress.ScriptPublicKeyString
-		if addedPairs, ok := utxoChanges.Added[listenerScriptPublicKeyString]; ok {
-			notification.Added = append(notification.Added,
-				ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(listenerAddress.Address, addedPairs)...)
-		}
-		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
-}
-
-// PropagateVirtualSelectedParentBlueScoreChangedNotifications instructs the listener to send
-// virtual selected parent blue score notifications to the remote listener
-func (nl *NotificationListener) PropagateVirtualSelectedParentBlueScoreChangedNotifications() {
-	nl.propagateVirtualSelectedParentBlueScoreChangedNotifications = true
-}

app/rpc/rpccontext/utxos_by_addresses.go

@@ -1,30 +0,0 @@
-package rpccontext
-
-import (
-	"encoding/hex"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/utxoindex"
-)
-
-// ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries converts
-// UTXOOutpointEntryPairs to a slice of UTXOsByAddressesEntry
-func ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(address string, pairs utxoindex.UTXOOutpointEntryPairs) []*appmessage.UTXOsByAddressesEntry {
-	utxosByAddressesEntries := make([]*appmessage.UTXOsByAddressesEntry, 0, len(pairs))
-	for outpoint, utxoEntry := range pairs {
-		utxosByAddressesEntries = append(utxosByAddressesEntries, &appmessage.UTXOsByAddressesEntry{
-			Address: address,
-			Outpoint: &appmessage.RPCOutpoint{
-				TransactionID: outpoint.TransactionID.String(),
-				Index:         outpoint.Index,
-			},
-			UTXOEntry: &appmessage.RPCUTXOEntry{
-				Amount:          utxoEntry.Amount(),
-				ScriptPublicKey: &appmessage.RPCScriptPublicKey{Script: hex.EncodeToString(utxoEntry.ScriptPublicKey().Script), Version: utxoEntry.ScriptPublicKey().Version},
-				BlockBlueScore:  utxoEntry.BlockBlueScore(),
-				IsCoinbase:      utxoEntry.IsCoinbase(),
-			},
-		})
-	}
-	return utxosByAddressesEntries
-}

app/rpc/rpccontext/verbosedata.go

@@ -3,14 +3,10 @@ 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/hashes"
-
 	"github.com/kaspanet/kaspad/domain/consensus/utils/estimatedsize"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
 
@@ -20,12 +16,15 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/pointers"
 )
 
 // BuildBlockVerboseData builds a BlockVerboseData from the given block.
-func (ctx *Context) BuildBlockVerboseData(blockHeader externalapi.BlockHeader, includeTransactionVerboseData bool) (*appmessage.BlockVerboseData, error) {
-	hash := consensushashing.HeaderHash(blockHeader)
+// This method must be called with the DAG lock held for reads
+func (ctx *Context) BuildBlockVerboseData(block *externalapi.DomainBlock, includeTransactionVerboseData bool) (*appmessage.BlockVerboseData, error) {
+	hash := consensushashing.BlockHash(block)
+	blockHeader := block.Header
 
 	blockInfo, err := ctx.Domain.Consensus().GetBlockInfo(hash)
 	if err != nil {
@@ -33,44 +32,36 @@ func (ctx *Context) BuildBlockVerboseData(blockHeader externalapi.BlockHeader, i
 	}
 	result := &appmessage.BlockVerboseData{
 		Hash:                 hash.String(),
-		Version:              blockHeader.Version(),
-		VersionHex:           fmt.Sprintf("%08x", blockHeader.Version()),
-		HashMerkleRoot:       blockHeader.HashMerkleRoot().String(),
-		AcceptedIDMerkleRoot: blockHeader.AcceptedIDMerkleRoot().String(),
-		UTXOCommitment:       blockHeader.UTXOCommitment().String(),
-		ParentHashes:         hashes.ToStrings(blockHeader.ParentHashes()),
-		Nonce:                blockHeader.Nonce(),
-		Time:                 blockHeader.TimeInMilliseconds(),
-		Bits:                 strconv.FormatInt(int64(blockHeader.Bits()), 16),
-		Difficulty:           ctx.GetDifficultyRatio(blockHeader.Bits(), ctx.Config.ActiveNetParams),
+		Version:              blockHeader.Version,
+		VersionHex:           fmt.Sprintf("%08x", blockHeader.Version),
+		HashMerkleRoot:       blockHeader.HashMerkleRoot.String(),
+		AcceptedIDMerkleRoot: blockHeader.AcceptedIDMerkleRoot.String(),
+		UTXOCommitment:       blockHeader.UTXOCommitment.String(),
+		ParentHashes:         externalapi.DomainHashesToStrings(blockHeader.ParentHashes),
+		Nonce:                blockHeader.Nonce,
+		Time:                 blockHeader.TimeInMilliseconds,
+		Bits:                 strconv.FormatInt(int64(blockHeader.Bits), 16),
+		Difficulty:           ctx.GetDifficultyRatio(blockHeader.Bits, ctx.Config.ActiveNetParams),
 		BlueScore:            blockInfo.BlueScore,
-		IsHeaderOnly:         blockInfo.BlockStatus == externalapi.StatusHeaderOnly,
 	}
 
-	if blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
-		block, err := ctx.Domain.Consensus().GetBlock(hash)
-		if err != nil {
-			return nil, err
-		}
+	txIDs := make([]string, len(block.Transactions))
+	for i, tx := range block.Transactions {
+		txIDs[i] = consensushashing.TransactionID(tx).String()
+	}
+	result.TxIDs = txIDs
 
-		txIDs := make([]string, len(block.Transactions))
+	if includeTransactionVerboseData {
+		transactionVerboseData := make([]*appmessage.TransactionVerboseData, len(block.Transactions))
 		for i, tx := range block.Transactions {
-			txIDs[i] = consensushashing.TransactionID(tx).String()
-		}
-		result.TxIDs = txIDs
-
-		if includeTransactionVerboseData {
-			transactionVerboseData := make([]*appmessage.TransactionVerboseData, len(block.Transactions))
-			for i, tx := range block.Transactions {
-				txID := consensushashing.TransactionID(tx).String()
-				data, err := ctx.BuildTransactionVerboseData(tx, txID, blockHeader, hash.String())
-				if err != nil {
-					return nil, err
-				}
-				transactionVerboseData[i] = data
+			txID := consensushashing.TransactionID(tx).String()
+			data, err := ctx.BuildTransactionVerboseData(tx, txID, blockHeader, hash.String())
+			if err != nil {
+				return nil, err
 			}
-			result.TransactionVerboseData = transactionVerboseData
+			transactionVerboseData[i] = data
 		}
+		result.TransactionVerboseData = transactionVerboseData
 	}
 
 	return result, nil
@@ -83,7 +74,7 @@ func (ctx *Context) GetDifficultyRatio(bits uint32, params *dagconfig.Params) fl
 	// converted back to a number. Note this is not the same as the proof of
 	// work limit directly because the block difficulty is encoded in a block
 	// with the compact form which loses precision.
-	target := difficulty.CompactToBig(bits)
+	target := util.CompactToBig(bits)
 
 	difficulty := new(big.Rat).SetFrac(params.PowMax, target)
 	diff, _ := difficulty.Float64()
@@ -97,7 +88,7 @@ func (ctx *Context) GetDifficultyRatio(bits uint32, params *dagconfig.Params) fl
 // BuildTransactionVerboseData builds a TransactionVerboseData from
 // the given parameters
 func (ctx *Context) BuildTransactionVerboseData(tx *externalapi.DomainTransaction, txID string,
-	blockHeader externalapi.BlockHeader, blockHash string) (
+	blockHeader *externalapi.DomainBlockHeader, blockHash string) (
 	*appmessage.TransactionVerboseData, error) {
 
 	var payloadHash string
@@ -120,8 +111,8 @@ func (ctx *Context) BuildTransactionVerboseData(tx *externalapi.DomainTransactio
 	}
 
 	if blockHeader != nil {
-		txReply.Time = uint64(blockHeader.TimeInMilliseconds())
-		txReply.BlockTime = uint64(blockHeader.TimeInMilliseconds())
+		txReply.Time = uint64(blockHeader.TimeInMilliseconds)
+		txReply.BlockTime = uint64(blockHeader.TimeInMilliseconds)
 		txReply.BlockHash = blockHash
 	}
 
@@ -134,7 +125,7 @@ func (ctx *Context) buildTransactionVerboseInputs(tx *externalapi.DomainTransact
 		// The disassembled string will contain [error] inline
 		// if the script doesn't fully parse, so ignore the
 		// error here.
-		disbuf, _ := txscript.DisasmString(constants.MaxScriptPublicKeyVersion, transactionInput.SignatureScript)
+		disbuf, _ := txscript.DisasmString(transactionInput.SignatureScript)
 
 		input := &appmessage.TransactionVerboseInput{}
 		input.TxID = transactionInput.PreviousOutpoint.TransactionID.String()
@@ -155,6 +146,9 @@ func (ctx *Context) buildTransactionVerboseInputs(tx *externalapi.DomainTransact
 func (ctx *Context) buildTransactionVerboseOutputs(tx *externalapi.DomainTransaction, filterAddrMap map[string]struct{}) []*appmessage.TransactionVerboseOutput {
 	outputs := make([]*appmessage.TransactionVerboseOutput, len(tx.Outputs))
 	for i, transactionOutput := range tx.Outputs {
+		// The disassembled string will contain [error] inline if the
+		// script doesn't fully parse, so ignore the error here.
+		disbuf, _ := txscript.DisasmString(transactionOutput.ScriptPublicKey)
 
 		// Ignore the error here since an error means the script
 		// couldn't parse and there is no additional information about
@@ -185,7 +179,8 @@ func (ctx *Context) buildTransactionVerboseOutputs(tx *externalapi.DomainTransac
 		output.Value = transactionOutput.Value
 		output.ScriptPubKey = &appmessage.ScriptPubKeyResult{
 			Address: encodedAddr,
-			Hex:     hex.EncodeToString(transactionOutput.ScriptPublicKey.Script),
+			Asm:     disbuf,
+			Hex:     hex.EncodeToString(transactionOutput.ScriptPublicKey),
 			Type:    scriptClass.String(),
 		}
 		outputs[i] = output

app/rpc/rpchandlers/get_block.go

@@ -3,7 +3,7 @@ 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"
 )
 
@@ -12,14 +12,14 @@ func HandleGetBlock(context *rpccontext.Context, _ *router.Router, request appme
 	getBlockRequest := request.(*appmessage.GetBlockRequestMessage)
 
 	// Load the raw block bytes from the database.
-	hash, err := externalapi.NewDomainHashFromString(getBlockRequest.Hash)
+	hash, err := hashes.FromString(getBlockRequest.Hash)
 	if err != nil {
 		errorMessage := &appmessage.GetBlockResponseMessage{}
 		errorMessage.Error = appmessage.RPCErrorf("Hash could not be parsed: %s", err)
 		return errorMessage, nil
 	}
 
-	header, err := context.Domain.Consensus().GetBlockHeader(hash)
+	block, err := context.Domain.Consensus().GetBlock(hash)
 	if err != nil {
 		errorMessage := &appmessage.GetBlockResponseMessage{}
 		errorMessage.Error = appmessage.RPCErrorf("Block %s not found", hash)
@@ -28,7 +28,7 @@ func HandleGetBlock(context *rpccontext.Context, _ *router.Router, request appme
 
 	response := appmessage.NewGetBlockResponseMessage()
 
-	blockVerboseData, err := context.BuildBlockVerboseData(header, getBlockRequest.IncludeTransactionVerboseData)
+	blockVerboseData, err := context.BuildBlockVerboseData(block, getBlockRequest.IncludeTransactionVerboseData)
 	if err != nil {
 		return nil, err
 	}

app/rpc/rpchandlers/get_block_template.go

@@ -33,10 +33,5 @@ func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, reque
 	}
 	msgBlock := appmessage.DomainBlockToMsgBlock(templateBlock)
 
-	isSynced, err := context.ProtocolManager.ShouldMine()
-	if err != nil {
-		return nil, err
-	}
-
-	return appmessage.NewGetBlockTemplateResponseMessage(msgBlock, isSynced), nil
+	return appmessage.NewGetBlockTemplateResponseMessage(msgBlock), nil
 }

app/rpc/rpchandlers/get_chain_from_block.go

@@ -0,0 +1,20 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+const (
+	// maxBlocksInGetChainFromBlockResponse is the max amount of blocks that
+	// are allowed in a GetChainFromBlockResponse.
+	maxBlocksInGetChainFromBlockResponse = 1000
+)
+
+// HandleGetChainFromBlock handles the respectively named RPC command
+func HandleGetChainFromBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	response := &appmessage.GetChainFromBlockResponseMessage{}
+	response.Error = appmessage.RPCErrorf("not implemented")
+	return response, nil
+}

app/rpc/rpchandlers/get_connected_peer_info.go

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

app/rpc/rpchandlers/get_mempool_entries.go

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

app/rpc/rpchandlers/get_mempool_entry.go

@@ -3,33 +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/transactionid"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
 // HandleGetMempoolEntry handles the respectively named RPC command
 func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	getMempoolEntryRequest := request.(*appmessage.GetMempoolEntryRequestMessage)
-
-	transactionID, err := transactionid.FromString(getMempoolEntryRequest.TxID)
-	if err != nil {
-		errorMessage := &appmessage.GetMempoolEntryResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Transaction ID could not be parsed: %s", err)
-		return errorMessage, nil
-	}
-
-	transaction, ok := context.Domain.MiningManager().GetTransaction(transactionID)
-	if !ok {
-		errorMessage := &appmessage.GetMempoolEntryResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Transaction %s was not found", transactionID)
-		return errorMessage, nil
-	}
-
-	transactionVerboseData, err := context.BuildTransactionVerboseData(
-		transaction, getMempoolEntryRequest.TxID, nil, "")
-	if err != nil {
-		return nil, err
-	}
-
-	return appmessage.NewGetMempoolEntryResponseMessage(transaction.Fee, transactionVerboseData), nil
+	return &appmessage.GetMempoolEntryResponseMessage{}, nil
 }

app/rpc/rpchandlers/get_selected_tip_hash.go

@@ -3,6 +3,7 @@ package rpchandlers
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
@@ -13,7 +14,8 @@ func HandleGetSelectedTipHash(context *rpccontext.Context, _ *router.Router, _ a
 		return nil, err
 	}
 
-	response := appmessage.NewGetSelectedTipHashResponseMessage(selectedTip.String())
+	response := appmessage.NewGetSelectedTipHashResponseMessage(
+		consensushashing.BlockHash(selectedTip).String())
 
 	return response, nil
 }

app/rpc/rpchandlers/get_utxos_by_addresses.go

@@ -1,45 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util"
-)
-
-// HandleGetUTXOsByAddresses handles the respectively named RPC command
-func HandleGetUTXOsByAddresses(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	if !context.Config.UTXOIndex {
-		errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --utxoindex")
-		return errorMessage, nil
-	}
-
-	getUTXOsByAddressesRequest := request.(*appmessage.GetUTXOsByAddressesRequestMessage)
-
-	allEntries := make([]*appmessage.UTXOsByAddressesEntry, 0)
-	for _, addressString := range getUTXOsByAddressesRequest.Addresses {
-		address, err := util.DecodeAddress(addressString, context.Config.ActiveNetParams.Prefix)
-		if err != nil {
-			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("Could not decode address '%s': %s", addressString, err)
-			return errorMessage, nil
-		}
-		scriptPublicKey, err := txscript.PayToAddrScript(address)
-		if err != nil {
-			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("Could not create a scriptPublicKey for address '%s': %s", addressString, err)
-			return errorMessage, nil
-		}
-		utxoOutpointEntryPairs, err := context.UTXOIndex.UTXOs(scriptPublicKey)
-		if err != nil {
-			return nil, err
-		}
-		entries := rpccontext.ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(addressString, utxoOutpointEntryPairs)
-		allEntries = append(allEntries, entries...)
-	}
-
-	response := appmessage.NewGetUTXOsByAddressesResponseMessage(allEntries)
-	return response, nil
-}

app/rpc/rpchandlers/get_virtual_selected_parent_blue_score.go

@@ -1,16 +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"
-)
-
-// HandleGetVirtualSelectedParentBlueScore handles the respectively named RPC command
-func HandleGetVirtualSelectedParentBlueScore(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	virtualInfo, err := context.Domain.Consensus().GetVirtualInfo()
-	if err != nil {
-		return nil, err
-	}
-	return appmessage.NewGetVirtualSelectedParentBlueScoreResponseMessage(virtualInfo.BlueScore), nil
-}

app/rpc/rpchandlers/get_virtual_selected_parent_chain_from_block.go

@@ -1,37 +0,0 @@
-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/infrastructure/network/netadapter/router"
-)
-
-// HandleGetVirtualSelectedParentChainFromBlock handles the respectively named RPC command
-func HandleGetVirtualSelectedParentChainFromBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	getVirtualSelectedParentChainFromBlockRequest := request.(*appmessage.GetVirtualSelectedParentChainFromBlockRequestMessage)
-
-	startHash, err := externalapi.NewDomainHashFromString(getVirtualSelectedParentChainFromBlockRequest.StartHash)
-	if err != nil {
-		errorMessage := &appmessage.GetVirtualSelectedParentChainFromBlockResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Could not parse startHash: %s", err)
-		return errorMessage, nil
-	}
-
-	virtualSelectedParentChain, err := context.Domain.Consensus().GetVirtualSelectedParentChainFromBlock(startHash)
-	if err != nil {
-		response := &appmessage.GetVirtualSelectedParentChainFromBlockResponseMessage{}
-		response.Error = appmessage.RPCErrorf("Could not build virtual "+
-			"selected parent chain from %s: %s", getVirtualSelectedParentChainFromBlockRequest.StartHash, err)
-		return response, nil
-	}
-
-	chainChangedNotification, err := context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(virtualSelectedParentChain)
-	if err != nil {
-		return nil, err
-	}
-
-	response := appmessage.NewGetVirtualSelectedParentChainFromBlockResponseMessage(
-		chainChangedNotification.RemovedChainBlockHashes, chainChangedNotification.AddedChainBlocks)
-	return response, nil
-}

app/rpc/rpchandlers/notify_chain_changed.go

@@ -6,14 +6,14 @@ import (
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
-// HandleNotifyVirtualSelectedParentBlueScoreChanged handles the respectively named RPC command
-func HandleNotifyVirtualSelectedParentBlueScoreChanged(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+// HandleNotifyChainChanged handles the respectively named RPC command
+func HandleNotifyChainChanged(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
 	listener, err := context.NotificationManager.Listener(router)
 	if err != nil {
 		return nil, err
 	}
-	listener.PropagateVirtualSelectedParentBlueScoreChangedNotifications()
+	listener.PropagateChainChangedNotifications()
 
-	response := appmessage.NewNotifyVirtualSelectedParentBlueScoreChangedResponseMessage()
+	response := appmessage.NewNotifyChainChangedResponseMessage()
 	return response, nil
 }

app/rpc/rpchandlers/notify_utxos_changed.go

@@ -1,51 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/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
-func HandleNotifyUTXOsChanged(context *rpccontext.Context, router *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	if !context.Config.UTXOIndex {
-		errorMessage := appmessage.NewNotifyUTXOsChangedResponseMessage()
-		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --utxoindex")
-		return errorMessage, nil
-	}
-
-	notifyUTXOsChangedRequest := request.(*appmessage.NotifyUTXOsChangedRequestMessage)
-
-	addresses := make([]*rpccontext.UTXOsChangedNotificationAddress, len(notifyUTXOsChangedRequest.Addresses))
-	for i, addressString := range notifyUTXOsChangedRequest.Addresses {
-		address, err := util.DecodeAddress(addressString, context.Config.ActiveNetParams.Prefix)
-		if err != nil {
-			errorMessage := appmessage.NewNotifyUTXOsChangedResponseMessage()
-			errorMessage.Error = appmessage.RPCErrorf("Could not decode address '%s': %s", addressString, err)
-			return errorMessage, nil
-		}
-		scriptPublicKey, err := txscript.PayToAddrScript(address)
-		if err != nil {
-			errorMessage := appmessage.NewNotifyUTXOsChangedResponseMessage()
-			errorMessage.Error = appmessage.RPCErrorf("Could not create a scriptPublicKey for address '%s': %s", addressString, err)
-			return errorMessage, nil
-		}
-		scriptPublicKeyString := utxoindex.ConvertScriptPublicKeyToString(scriptPublicKey)
-		addresses[i] = &rpccontext.UTXOsChangedNotificationAddress{
-			Address:               addressString,
-			ScriptPublicKeyString: scriptPublicKeyString,
-		}
-	}
-
-	listener, err := context.NotificationManager.Listener(router)
-	if err != nil {
-		return nil, err
-	}
-	listener.PropagateUTXOsChangedNotifications(addresses)
-
-	response := appmessage.NewNotifyUTXOsChangedResponseMessage()
-	return response, nil
-}

app/rpc/rpchandlers/notify_virtual_selected_parent_chain_changed.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"
-)
-
-// HandleNotifyVirtualSelectedParentChainChanged handles the respectively named RPC command
-func HandleNotifyVirtualSelectedParentChainChanged(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	listener, err := context.NotificationManager.Listener(router)
-	if err != nil {
-		return nil, err
-	}
-	listener.PropagateVirtualSelectedParentChainChangedNotifications()
-
-	response := appmessage.NewNotifyVirtualSelectedParentChainChangedResponseMessage()
-	return response, nil
-}

app/rpc/rpchandlers/submit_block.go

@@ -3,10 +3,8 @@ package rpchandlers
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/pkg/errors"
 )
 
 // HandleSubmitBlock handles the respectively named RPC command
@@ -16,22 +14,11 @@ func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request ap
 	msgBlock := submitBlockRequest.Block
 	domainBlock := appmessage.MsgBlockToDomainBlock(msgBlock)
 
-	if context.ProtocolManager.IsIBDRunning() {
-		return &appmessage.SubmitBlockResponseMessage{
-			Error:        appmessage.RPCErrorf("Block not submitted - IBD is running"),
-			RejectReason: appmessage.RejectReasonIsInIBD,
-		}, nil
-	}
-
 	err := context.ProtocolManager.AddBlock(domainBlock)
 	if err != nil {
-		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return nil, err
-		}
-		return &appmessage.SubmitBlockResponseMessage{
-			Error:        appmessage.RPCErrorf("Block rejected. Reason: %s", err),
-			RejectReason: appmessage.RejectReasonBlockInvalid,
-		}, nil
+		errorMessage := &appmessage.SubmitBlockResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Block rejected. Reason: %s", err)
+		return errorMessage, nil
 	}
 
 	log.Infof("Accepted block %s via submitBlock", consensushashing.BlockHash(domainBlock))

app/rpc/rpchandlers/submit_transaction.go

@@ -13,15 +13,9 @@ import (
 func HandleSubmitTransaction(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
 	submitTransactionRequest := request.(*appmessage.SubmitTransactionRequestMessage)
 
-	domainTransaction, err := appmessage.RPCTransactionToDomainTransaction(submitTransactionRequest.Transaction)
-	if err != nil {
-		errorMessage := &appmessage.SubmitTransactionResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Could not parse transaction: %s", err)
-		return errorMessage, nil
-	}
-
+	domainTransaction := appmessage.MsgTxToDomainTransaction(submitTransactionRequest.Transaction)
 	transactionID := consensushashing.TransactionID(domainTransaction)
-	err = context.ProtocolManager.AddTransaction(domainTransaction)
+	err := context.ProtocolManager.AddTransaction(domainTransaction)
 	if err != nil {
 		if !errors.As(err, &mempool.RuleError{}) {
 			return nil, err

build_and_test.sh

@@ -1,27 +0,0 @@
-#!/bin/sh -ex
-
-FLAGS=$@
-
-go version
-
-go get $FLAGS -t -d ./...
-# This is to bypass a go bug: https://github.com/golang/go/issues/27643
-GO111MODULE=off go get $FLAGS golang.org/x/lint/golint \
-                          honnef.co/go/tools/cmd/staticcheck
-
-test -z "$(go fmt ./...)"
-
-golint -set_exit_status ./...
-
-staticcheck -checks SA4006,SA4008,SA4009,SA4010,SA5003,SA1004,SA1014,SA1021,SA1023,SA1024,SA1025,SA1026,SA1027,SA1028,SA2000,SA2001,SA2003,SA4000,SA4001,SA4003,SA4004,SA4011,SA4012,SA4013,SA4014,SA4015,SA4016,SA4017,SA4018,SA4019,SA4020,SA4021,SA4022,SA4023,SA5000,SA5002,SA5004,SA5005,SA5007,SA5008,SA5009,SA5010,SA5011,SA5012,SA6001,SA6002,SA9001,SA9002,SA9003,SA9004,SA9005,SA9006,ST1019 ./...
-
-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

cmd/gencerts/gencerts.go

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

cmd/kaspactl/README.md

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