Fixed version

.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 = 16gb ,
-    [System.UInt64] $MaximumSize = 16gb ,
-    [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/deploy.yaml

@@ -1,76 +0,0 @@
-name: Build and upload assets
-on:
-  release:
-    types: [ published ]
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
-    name: Building, ${{ matrix.os }}
-    steps:
-      - name: Fix CRLF on Windows
-        if: runner.os == 'Windows'
-        run: git config --global core.autocrlf false
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
-
-      # Increase the pagefile size on Windows to aviod running out of memory
-      - name: Increase pagefile size on Windows
-        if: runner.os == 'Windows'
-        run: powershell -command .github\workflows\SetPageFileSize.ps1
-
-
-      - name: Setup Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.16
-
-      - name: Build on Linux
-        if: runner.os == 'Linux'
-        # `-extldflags=-static` - means static link everything,
-        # `-tags netgo,osusergo` means use pure go replacements for "os/user" and "net"
-        # `-s -w` strips the binary to produce smaller size binaries
-        run: |
-          go build -v -ldflags="-s -w -extldflags=-static" -tags netgo,osusergo -o ./bin/ . ./cmd/...
-          archive="bin/kaspad-${{ github.event.release.tag_name }}-linux.zip"
-          asset_name="kaspad-${{ github.event.release.tag_name }}-linux.zip"
-          zip -r "${archive}" ./bin/*
-          echo "archive=${archive}" >> $GITHUB_ENV
-          echo "asset_name=${asset_name}" >> $GITHUB_ENV
-
-      - name: Build on Windows
-        if: runner.os == 'Windows'
-        shell: bash
-        run: |
-          go build -v -ldflags="-s -w" -o bin/ . ./cmd/...
-          archive="bin/kaspad-${{ github.event.release.tag_name }}-win64.zip"
-          asset_name="kaspad-${{ github.event.release.tag_name }}-win64.zip"
-          powershell "Compress-Archive bin/* \"${archive}\""
-          echo "archive=${archive}" >> $GITHUB_ENV
-          echo "asset_name=${asset_name}" >> $GITHUB_ENV
-
-      - name: Build on MacOS
-        if: runner.os == 'macOS'
-        run: |
-          go build -v -ldflags="-s -w" -o ./bin/ . ./cmd/...
-          archive="bin/kaspad-${{ github.event.release.tag_name }}-osx.zip"
-          asset_name="kaspad-${{ github.event.release.tag_name }}-osx.zip"
-          zip -r "${archive}" ./bin/*
-          echo "archive=${archive}" >> $GITHUB_ENV
-          echo "asset_name=${asset_name}" >> $GITHUB_ENV
-
-
-      - name: Upload release asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ github.event.release.upload_url }}
-          asset_path: "./${{ env.archive }}"
-          asset_name: "${{ env.asset_name }}"
-          asset_content_type: application/zip

.github/workflows/race.yaml

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

.github/workflows/tests.yaml

@@ -1,98 +0,0 @@
-name: Tests
-
-on:
-  push:
-  pull_request:
-    # edtited - because base branch can be modified
-    # synchronize - update commits on PR
-    types: [opened, synchronize, edited]
-
-jobs:
-
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ ubuntu-latest, macos-latest ]
-    name: Tests, ${{ matrix.os }}
-    steps:
-
-      - name: Fix CRLF on Windows
-        if: runner.os == 'Windows'
-        run: git config --global core.autocrlf false
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
-
-      # Increase the pagefile size on Windows to aviod running out of memory
-      - name: Increase pagefile size on Windows
-        if: runner.os == 'Windows'
-        run: powershell -command .github\workflows\SetPageFileSize.ps1
-
-      - name: Setup Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.16
-
-
-      # 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 -v
-
-
-  stability-test-fast:
-    runs-on: ubuntu-latest
-    name: Fast stability tests, ${{ github.head_ref }}
-    steps:
-
-      - name: Setup Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.16
-
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-
-      - name: Install kaspad
-        run: go install ./...
-
-      - name: Install golint
-        run: go get -u golang.org/x/lint/golint
-
-      - name: Run fast stability tests
-        working-directory: stability-tests
-        run: ./install_and_test.sh
-
-
-  coverage:
-    runs-on: ubuntu-latest
-    name: Produce code coverage
-    steps:
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
-
-      - name: Setup Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.16
-
-      - name: Delete the stability tests from coverage
-        run: rm -r stability-tests
-
-      - name: Create coverage file
-        run: go test -v -covermode=atomic -coverpkg=./... -coverprofile coverage.txt ./...
-
-      - 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.16 or later.
+Latest version of [Go](http://golang.org) (currently 1.13).
 
 ## Installation
 
@@ -31,17 +27,23 @@ Go 1.16 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,24 +53,25 @@ $ 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
-Join our discord server using the following link: https://discord.gg/YNYnNN5Pf2
+Join our discord server using the following link: https://discord.gg/WmGhhzk
 
 ## Issue Tracker
 
 The [integrated github issue tracker](https://github.com/kaspanet/kaspad/issues)
 is used for this project.
 
-Issue priorities may be seen at https://github.com/orgs/kaspanet/projects/4
-
 ## Documentation
 
-The [documentation](https://github.com/kaspanet/docs) 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/app.go

@@ -7,20 +7,20 @@ import (
 	"runtime"
 	"time"
 
-	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/db/database"
 	"github.com/kaspanet/kaspad/infrastructure/db/database/ldb"
-	"github.com/kaspanet/kaspad/infrastructure/logger"
-	"github.com/kaspanet/kaspad/infrastructure/os/execenv"
-	"github.com/kaspanet/kaspad/infrastructure/os/limits"
+
 	"github.com/kaspanet/kaspad/infrastructure/os/signal"
-	"github.com/kaspanet/kaspad/infrastructure/os/winservice"
-	"github.com/kaspanet/kaspad/util/panics"
 	"github.com/kaspanet/kaspad/util/profiling"
 	"github.com/kaspanet/kaspad/version"
-)
 
-const leveldbCacheSizeMiB = 256
+	"github.com/kaspanet/kaspad/util/panics"
+
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/os/execenv"
+	"github.com/kaspanet/kaspad/infrastructure/os/limits"
+	"github.com/kaspanet/kaspad/infrastructure/os/winservice"
+)
 
 var desiredLimits = &limits.DesiredLimits{
 	FileLimitWant: 2048,
@@ -49,7 +49,6 @@ func StartApp() error {
 		fmt.Fprintln(os.Stderr, err)
 		return err
 	}
-	defer logger.BackendLog.Close()
 	defer panics.HandlePanic(log, "MAIN", nil)
 
 	app := &kaspadApp{cfg: cfg}
@@ -85,6 +84,12 @@ func (app *kaspadApp) main(startedChan chan<- struct{}) error {
 		profiling.Start(app.cfg.Profile, log)
 	}
 
+	// Perform upgrades to kaspad as new versions require it.
+	if err := doUpgrades(); err != nil {
+		log.Error(err)
+		return err
+	}
+
 	// Return now if an interrupt signal was triggered.
 	if signal.InterruptRequested(interrupt) {
 		return nil
@@ -101,7 +106,7 @@ func (app *kaspadApp) main(startedChan chan<- struct{}) error {
 	// Open the database
 	databaseContext, err := openDB(app.cfg)
 	if err != nil {
-		log.Errorf("Loading database failed: %+v", err)
+		log.Error(err)
 		return err
 	}
 
@@ -157,9 +162,15 @@ func (app *kaspadApp) main(startedChan chan<- struct{}) error {
 	return nil
 }
 
+// doUpgrades performs upgrades to kaspad as new versions require it.
+// currently it's a placeholder we got from kaspad upstream, that does nothing
+func doUpgrades() error {
+	return nil
+}
+
 // dbPath returns the path to the block database given a database type.
 func databasePath(cfg *config.Config) string {
-	return filepath.Join(cfg.AppDir, "data")
+	return filepath.Join(cfg.DataDir, "db")
 }
 
 func removeDatabase(cfg *config.Config) error {
@@ -169,17 +180,6 @@ func removeDatabase(cfg *config.Config) error {
 
 func openDB(cfg *config.Config) (database.Database, error) {
 	dbPath := databasePath(cfg)
-
-	err := checkDatabaseVersion(dbPath)
-	if err != nil {
-		return nil, err
-	}
-
 	log.Infof("Loading database from '%s'", dbPath)
-	db, err := ldb.NewLevelDB(dbPath, leveldbCacheSizeMiB)
-	if err != nil {
-		return nil, err
-	}
-
-	return db, nil
+	return ldb.NewLevelDB(dbPath)
 }

app/appmessage/common.go

@@ -5,12 +5,34 @@
 package appmessage
 
 import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"math"
+
+	"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
 
+var (
+	// littleEndian is a convenience variable since binary.LittleEndian is
+	// quite long.
+	littleEndian = binary.LittleEndian
+
+	// bigEndian is a convenience variable since binary.BigEndian is quite
+	// long.
+	bigEndian = binary.BigEndian
+)
+
 // errNonCanonicalVarInt is the common format string used for non-canonically
 // encoded variable length integer errors.
 var errNonCanonicalVarInt = "non-canonical varint %x - discriminant %x must " +
@@ -18,3 +40,473 @@ 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, littleEndian)
+		if err != nil {
+			return err
+		}
+		*e = int32(rv)
+		return nil
+
+	case *uint32:
+		rv, err := binaryserializer.Uint32(r, littleEndian)
+		if err != nil {
+			return err
+		}
+		*e = rv
+		return nil
+
+	case *int64:
+		rv, err := binaryserializer.Uint64(r, littleEndian)
+		if err != nil {
+			return err
+		}
+		*e = int64(rv)
+		return nil
+
+	case *uint64:
+		rv, err := binaryserializer.Uint64(r, littleEndian)
+		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, binary.LittleEndian)
+		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, littleEndian)
+		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, littleEndian)
+		if err != nil {
+			return err
+		}
+		*e = ServiceFlag(rv)
+		return nil
+
+	case *KaspaNet:
+		rv, err := binaryserializer.Uint32(r, littleEndian)
+		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, littleEndian, uint32(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case uint32:
+		err := binaryserializer.PutUint32(w, littleEndian, e)
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case int64:
+		err := binaryserializer.PutUint64(w, littleEndian, uint64(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case uint64:
+		err := binaryserializer.PutUint64(w, littleEndian, 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, littleEndian, 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, littleEndian, uint64(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case KaspaNet:
+		err := binaryserializer.PutUint32(w, littleEndian, 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, littleEndian)
+		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, littleEndian)
+		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, littleEndian)
+		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
+}
+
+// WriteVarInt serializes val to w using a variable number of bytes depending
+// on its value.
+func WriteVarInt(w io.Writer, val uint64) error {
+	if val < 0xfd {
+		_, err := w.Write([]byte{uint8(val)})
+		return errors.WithStack(err)
+	}
+
+	if val <= math.MaxUint16 {
+		var buf [3]byte
+		buf[0] = 0xfd
+		littleEndian.PutUint16(buf[1:], uint16(val))
+		_, err := w.Write(buf[:])
+		return errors.WithStack(err)
+	}
+
+	if val <= math.MaxUint32 {
+		var buf [5]byte
+		buf[0] = 0xfe
+		littleEndian.PutUint32(buf[1:], uint32(val))
+		_, err := w.Write(buf[:])
+		return errors.WithStack(err)
+	}
+
+	var buf [9]byte
+	buf[0] = 0xff
+	littleEndian.PutUint64(buf[1:], val)
+	_, err := w.Write(buf[:])
+	return errors.WithStack(err)
+}
+
+// VarIntSerializeSize returns the number of bytes it would take to serialize
+// val as a variable length integer.
+func VarIntSerializeSize(val uint64) int {
+	// The value is small enough to be represented by itself, so it's
+	// just 1 byte.
+	if val < 0xfd {
+		return 1
+	}
+
+	// Discriminant 1 byte plus 2 bytes for the uint16.
+	if val <= math.MaxUint16 {
+		return 3
+	}
+
+	// Discriminant 1 byte plus 4 bytes for the uint32.
+	if val <= math.MaxUint32 {
+		return 5
+	}
+
+	// Discriminant 1 byte plus 8 bytes for the uint64.
+	return 9
+}
+
+// ReadVarString reads a variable length string from r and returns it as a Go
+// string. A variable length string is encoded as a variable length integer
+// containing the length of the string followed by the bytes that represent the
+// string itself. An error is returned if the length is greater than the
+// maximum block payload size since it helps protect against memory exhaustion
+// attacks and forced panics through malformed messages.
+func ReadVarString(r io.Reader, pver uint32) (string, error) {
+	count, err := ReadVarInt(r)
+	if err != nil {
+		return "", err
+	}
+
+	// Prevent variable length strings that are larger than the maximum
+	// message size. It would be possible to cause memory exhaustion and
+	// panics without a sane upper bound on this count.
+	if count > MaxMessagePayload {
+		str := fmt.Sprintf("variable length string is too long "+
+			"[count %d, max %d]", count, MaxMessagePayload)
+		return "", messageError("ReadVarString", str)
+	}
+
+	buf := make([]byte, count)
+	_, err = io.ReadFull(r, buf)
+	if err != nil {
+		return "", err
+	}
+	return string(buf), nil
+}
+
+// WriteVarString serializes str to w as a variable length integer containing
+// the length of the string followed by the bytes that represent the string
+// itself.
+func WriteVarString(w io.Writer, str string) error {
+	err := WriteVarInt(w, uint64(len(str)))
+	if err != nil {
+		return err
+	}
+	_, err = w.Write([]byte(str))
+	return err
+}
+
+// ReadVarBytes reads a variable length byte array. A byte array is encoded
+// as a varInt containing the length of the array followed by the bytes
+// themselves. An error is returned if the length is greater than the
+// passed maxAllowed parameter which helps protect against memory exhaustion
+// attacks and forced panics through malformed messages. The fieldName
+// parameter is only used for the error message so it provides more context in
+// the error.
+func ReadVarBytes(r io.Reader, pver uint32, maxAllowed uint32,
+	fieldName string) ([]byte, error) {
+
+	count, err := ReadVarInt(r)
+	if err != nil {
+		return nil, err
+	}
+
+	// Prevent byte array larger than the max message size. It would
+	// be possible to cause memory exhaustion and panics without a sane
+	// upper bound on this count.
+	if count > uint64(maxAllowed) {
+		str := fmt.Sprintf("%s is larger than the max allowed size "+
+			"[count %d, max %d]", fieldName, count, maxAllowed)
+		return nil, messageError("ReadVarBytes", str)
+	}
+
+	b := make([]byte, count)
+	_, err = io.ReadFull(r, b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
+
+// WriteVarBytes serializes a variable length byte array to w as a varInt
+// containing the number of bytes, followed by the bytes themselves.
+func WriteVarBytes(w io.Writer, pver uint32, bytes []byte) error {
+	slen := uint64(len(bytes))
+	err := WriteVarInt(w, slen)
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write(bytes)
+	return err
+}

app/appmessage/common_test.go

@@ -1,44 +1,696 @@
+// 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"
+	"strings"
+	"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
+		}
+	}
+}
+
+// TestVarIntEncoding tests appmessage encode and decode for variable length integers.
+func TestVarIntEncoding(t *testing.T) {
+	tests := []struct {
+		value uint64 // Value to encode
+		buf   []byte // Encoded value
+	}{
+		// Latest protocol version.
+		// Single byte
+		{0, []byte{0x00}},
+		// Max single byte
+		{0xfc, []byte{0xfc}},
+		// Min 2-byte
+		{0xfd, []byte{0xfd, 0x0fd, 0x00}},
+		// Max 2-byte
+		{0xffff, []byte{0xfd, 0xff, 0xff}},
+		// Min 4-byte
+		{0x10000, []byte{0xfe, 0x00, 0x00, 0x01, 0x00}},
+		// Max 4-byte
+		{0xffffffff, []byte{0xfe, 0xff, 0xff, 0xff, 0xff}},
+		// Min 8-byte
+		{
+			0x100000000,
+			[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00},
+		},
+		// Max 8-byte
+		{
+			0xffffffffffffffff,
+			[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+		},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		buf := &bytes.Buffer{}
+		err := WriteVarInt(buf, test.value)
+		if err != nil {
+			t.Errorf("WriteVarInt #%d error %v", i, err)
+			continue
+		}
+		if !bytes.Equal(buf.Bytes(), test.buf) {
+			t.Errorf("WriteVarInt #%d\n got: %s want: %s", i,
+				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
+			continue
+		}
+
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.buf)
+		val, err := ReadVarInt(rbuf)
+		if err != nil {
+			t.Errorf("ReadVarInt #%d error %v", i, err)
+			continue
+		}
+		if val != test.value {
+			t.Errorf("ReadVarInt #%d\n got: %x want: %x", i,
+				val, test.value)
+			continue
+		}
+	}
+}
+
+// TestVarIntEncodingErrors performs negative tests against appmessage encode and decode
+// of variable length integers to confirm error paths work correctly.
+func TestVarIntEncodingErrors(t *testing.T) {
+	tests := []struct {
+		in       uint64 // Value to encode
+		buf      []byte // Encoded value
+		max      int    // Max size of fixed buffer to induce errors
+		writeErr error  // Expected write error
+		readErr  error  // Expected read error
+	}{
+		// Force errors on discriminant.
+		{0, []byte{0x00}, 0, io.ErrShortWrite, io.EOF},
+		// Force errors on 2-byte read/write.
+		{0xfd, []byte{0xfd}, 0, io.ErrShortWrite, io.EOF},              // error on writing length
+		{0xfd, []byte{0xfd}, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, // error on writing actual data
+		// Force errors on 4-byte read/write.
+		{0x10000, []byte{0xfe}, 0, io.ErrShortWrite, io.EOF},              // error on writing length
+		{0x10000, []byte{0xfe}, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, // error on writing actual data
+		// Force errors on 8-byte read/write.
+		{0x100000000, []byte{0xff}, 0, io.ErrShortWrite, io.EOF},              // error on writing length
+		{0x100000000, []byte{0xff}, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, // error on writing actual data
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		w := newFixedWriter(test.max)
+		err := WriteVarInt(w, test.in)
+		if !errors.Is(err, test.writeErr) {
+			t.Errorf("WriteVarInt #%d wrong error got: %v, want: %v",
+				i, err, test.writeErr)
+			continue
+		}
+
+		// Decode from appmessage format.
+		r := newFixedReader(test.max, test.buf)
+		_, err = ReadVarInt(r)
+		if !errors.Is(err, test.readErr) {
+			t.Errorf("ReadVarInt #%d wrong error got: %v, want: %v",
+				i, err, test.readErr)
+			continue
+		}
+	}
+}
+
+// TestVarIntNonCanonical ensures variable length integers that are not encoded
+// canonically return the expected error.
+func TestVarIntNonCanonical(t *testing.T) {
+	pver := ProtocolVersion
+
+	tests := []struct {
+		name string // Test name for easier identification
+		in   []byte // Value to decode
+		pver uint32 // Protocol version for appmessage encoding
+	}{
+		{
+			"0 encoded with 3 bytes", []byte{0xfd, 0x00, 0x00},
+			pver,
+		},
+		{
+			"max single-byte value encoded with 3 bytes",
+			[]byte{0xfd, 0xfc, 0x00}, pver,
+		},
+		{
+			"0 encoded with 5 bytes",
+			[]byte{0xfe, 0x00, 0x00, 0x00, 0x00}, pver,
+		},
+		{
+			"max three-byte value encoded with 5 bytes",
+			[]byte{0xfe, 0xff, 0xff, 0x00, 0x00}, pver,
+		},
+		{
+			"0 encoded with 9 bytes",
+			[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+			pver,
+		},
+		{
+			"max five-byte value encoded with 9 bytes",
+			[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00},
+			pver,
+		},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.in)
+		val, err := ReadVarInt(rbuf)
+		if msgErr := &(MessageError{}); !errors.As(err, &msgErr) {
+			t.Errorf("ReadVarInt #%d (%s) unexpected error %v", i,
+				test.name, err)
+			continue
+		}
+		if val != 0 {
+			t.Errorf("ReadVarInt #%d (%s)\n got: %d want: 0", i,
+				test.name, val)
+			continue
+		}
+	}
+}
+
+// TestVarIntEncoding tests the serialize size for variable length integers.
+func TestVarIntSerializeSize(t *testing.T) {
+	tests := []struct {
+		val  uint64 // Value to get the serialized size for
+		size int    // Expected serialized size
+	}{
+		// Single byte
+		{0, 1},
+		// Max single byte
+		{0xfc, 1},
+		// Min 2-byte
+		{0xfd, 3},
+		// Max 2-byte
+		{0xffff, 3},
+		// Min 4-byte
+		{0x10000, 5},
+		// Max 4-byte
+		{0xffffffff, 5},
+		// Min 8-byte
+		{0x100000000, 9},
+		// Max 8-byte
+		{0xffffffffffffffff, 9},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		serializedSize := VarIntSerializeSize(test.val)
+		if serializedSize != test.size {
+			t.Errorf("VarIntSerializeSize #%d got: %d, want: %d", i,
+				serializedSize, test.size)
+			continue
+		}
+	}
+}
+
+// TestVarStringEncoding tests appmessage encode and decode for variable length strings.
+func TestVarStringEncoding(t *testing.T) {
+	pver := ProtocolVersion
+
+	// str256 is a string that takes a 2-byte varint to encode.
+	str256 := strings.Repeat("test", 64)
+
+	tests := []struct {
+		in   string // String to encode
+		out  string // String to decoded value
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
+	}{
+		// Latest protocol version.
+		// Empty string
+		{"", "", []byte{0x00}, pver},
+		// Single byte varint + string
+		{"Test", "Test", append([]byte{0x04}, []byte("Test")...), pver},
+		// 2-byte varint + string
+		{str256, str256, append([]byte{0xfd, 0x00, 0x01}, []byte(str256)...), pver},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		var buf bytes.Buffer
+		err := WriteVarString(&buf, test.in)
+		if err != nil {
+			t.Errorf("WriteVarString #%d error %v", i, err)
+			continue
+		}
+		if !bytes.Equal(buf.Bytes(), test.buf) {
+			t.Errorf("WriteVarString #%d\n got: %s want: %s", i,
+				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
+			continue
+		}
+
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.buf)
+		val, err := ReadVarString(rbuf, test.pver)
+		if err != nil {
+			t.Errorf("ReadVarString #%d error %v", i, err)
+			continue
+		}
+		if val != test.out {
+			t.Errorf("ReadVarString #%d\n got: %s want: %s", i,
+				val, test.out)
+			continue
+		}
+	}
+}
+
+// TestVarStringEncodingErrors performs negative tests against appmessage encode and
+// decode of variable length strings to confirm error paths work correctly.
+func TestVarStringEncodingErrors(t *testing.T) {
+	pver := ProtocolVersion
+
+	// str256 is a string that takes a 2-byte varint to encode.
+	str256 := strings.Repeat("test", 64)
+
+	tests := []struct {
+		in       string // Value to encode
+		buf      []byte // Encoded value
+		pver     uint32 // Protocol version for appmessage encoding
+		max      int    // Max size of fixed buffer to induce errors
+		writeErr error  // Expected write error
+		readErr  error  // Expected read error
+	}{
+		// Latest protocol version with intentional read/write errors.
+		// Force errors on empty string.
+		{"", []byte{0x00}, pver, 0, io.ErrShortWrite, io.EOF},
+		// Force error on single byte varint + string.
+		{"Test", []byte{0x04}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
+		// Force errors on 2-byte varint + string.
+		{str256, []byte{0xfd}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		w := newFixedWriter(test.max)
+		err := WriteVarString(w, test.in)
+		if !errors.Is(err, test.writeErr) {
+			t.Errorf("WriteVarString #%d wrong error got: %v, want: %v",
+				i, err, test.writeErr)
+			continue
+		}
+
+		// Decode from appmessage format.
+		r := newFixedReader(test.max, test.buf)
+		_, err = ReadVarString(r, test.pver)
+		if !errors.Is(err, test.readErr) {
+			t.Errorf("ReadVarString #%d wrong error got: %v, want: %v",
+				i, err, test.readErr)
+			continue
+		}
+	}
+}
+
+// TestVarStringOverflowErrors performs tests to ensure deserializing variable
+// length strings intentionally crafted to use large values for the string
+// length are handled properly. This could otherwise potentially be used as an
+// attack vector.
+func TestVarStringOverflowErrors(t *testing.T) {
+	pver := ProtocolVersion
+
+	tests := []struct {
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
+		err  error  // Expected error
+	}{
+		{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+			pver, &MessageError{}},
+		{[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
+			pver, &MessageError{}},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.buf)
+		_, err := ReadVarString(rbuf, test.pver)
+		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
+			t.Errorf("ReadVarString #%d wrong error got: %v, "+
+				"want: %v", i, err, reflect.TypeOf(test.err))
+			continue
+		}
+	}
+
+}
+
+// TestVarBytesEncoding tests appmessage encode and decode for variable length byte array.
+func TestVarBytesEncoding(t *testing.T) {
+	pver := ProtocolVersion
+
+	// bytes256 is a byte array that takes a 2-byte varint to encode.
+	bytes256 := bytes.Repeat([]byte{0x01}, 256)
+
+	tests := []struct {
+		in   []byte // Byte Array to write
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
+	}{
+		// Latest protocol version.
+		// Empty byte array
+		{[]byte{}, []byte{0x00}, pver},
+		// Single byte varint + byte array
+		{[]byte{0x01}, []byte{0x01, 0x01}, pver},
+		// 2-byte varint + byte array
+		{bytes256, append([]byte{0xfd, 0x00, 0x01}, bytes256...), pver},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		var buf bytes.Buffer
+		err := WriteVarBytes(&buf, test.pver, test.in)
+		if err != nil {
+			t.Errorf("WriteVarBytes #%d error %v", i, err)
+			continue
+		}
+		if !bytes.Equal(buf.Bytes(), test.buf) {
+			t.Errorf("WriteVarBytes #%d\n got: %s want: %s", i,
+				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
+			continue
+		}
+
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.buf)
+		val, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
+			"test payload")
+		if err != nil {
+			t.Errorf("ReadVarBytes #%d error %v", i, err)
+			continue
+		}
+		if !bytes.Equal(buf.Bytes(), test.buf) {
+			t.Errorf("ReadVarBytes #%d\n got: %s want: %s", i,
+				val, test.buf)
+			continue
+		}
+	}
+}
+
+// TestVarBytesEncodingErrors performs negative tests against appmessage encode and
+// decode of variable length byte arrays to confirm error paths work correctly.
+func TestVarBytesEncodingErrors(t *testing.T) {
+	pver := ProtocolVersion
+
+	// bytes256 is a byte array that takes a 2-byte varint to encode.
+	bytes256 := bytes.Repeat([]byte{0x01}, 256)
+
+	tests := []struct {
+		in       []byte // Byte Array to write
+		buf      []byte // Encoded value
+		pver     uint32 // Protocol version for appmessage encoding
+		max      int    // Max size of fixed buffer to induce errors
+		writeErr error  // Expected write error
+		readErr  error  // Expected read error
+	}{
+		// Latest protocol version with intentional read/write errors.
+		// Force errors on empty byte array.
+		{[]byte{}, []byte{0x00}, pver, 0, io.ErrShortWrite, io.EOF},
+		// Force error on single byte varint + byte array.
+		{[]byte{0x01, 0x02, 0x03}, []byte{0x04}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
+		// Force errors on 2-byte varint + byte array.
+		{bytes256, []byte{0xfd}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		w := newFixedWriter(test.max)
+		err := WriteVarBytes(w, test.pver, test.in)
+		if !errors.Is(err, test.writeErr) {
+			t.Errorf("WriteVarBytes #%d wrong error got: %v, want: %v",
+				i, err, test.writeErr)
+			continue
+		}
+
+		// Decode from appmessage format.
+		r := newFixedReader(test.max, test.buf)
+		_, err = ReadVarBytes(r, test.pver, MaxMessagePayload,
+			"test payload")
+		if !errors.Is(err, test.readErr) {
+			t.Errorf("ReadVarBytes #%d wrong error got: %v, want: %v",
+				i, err, test.readErr)
+			continue
+		}
+	}
+}
+
+// TestVarBytesOverflowErrors performs tests to ensure deserializing variable
+// length byte arrays intentionally crafted to use large values for the array
+// length are handled properly. This could otherwise potentially be used as an
+// attack vector.
+func TestVarBytesOverflowErrors(t *testing.T) {
+	pver := ProtocolVersion
+
+	tests := []struct {
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
+		err  error  // Expected error
+	}{
+		{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+			pver, &MessageError{}},
+		{[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
+			pver, &MessageError{}},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.buf)
+		_, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
+			"test payload")
+		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
+			t.Errorf("ReadVarBytes #%d wrong error got: %v, "+
+				"want: %v", i, err, reflect.TypeOf(test.err))
+			continue
+		}
+	}
+
+}

app/appmessage/domainconverters.go

@@ -1,17 +1,7 @@
 package appmessage
 
 import (
-	"encoding/hex"
-	"github.com/pkg/errors"
-	"math/big"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/blockheader"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
-	"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"
 )
 
@@ -27,21 +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(),
-		Parents:              domainBlockHeader.Parents(),
-		HashMerkleRoot:       domainBlockHeader.HashMerkleRoot(),
-		AcceptedIDMerkleRoot: domainBlockHeader.AcceptedIDMerkleRoot(),
-		UTXOCommitment:       domainBlockHeader.UTXOCommitment(),
-		Timestamp:            mstime.UnixMilliseconds(domainBlockHeader.TimeInMilliseconds()),
-		Bits:                 domainBlockHeader.Bits(),
-		Nonce:                domainBlockHeader.Nonce(),
-		BlueScore:            domainBlockHeader.BlueScore(),
-		DAAScore:             domainBlockHeader.DAAScore(),
-		BlueWork:             domainBlockHeader.BlueWork(),
-		PruningPoint:         domainBlockHeader.PruningPoint(),
+		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,
 	}
 }
 
@@ -58,22 +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.Parents,
-		blockHeader.HashMerkleRoot,
-		blockHeader.AcceptedIDMerkleRoot,
-		blockHeader.UTXOCommitment,
-		blockHeader.Timestamp.UnixMilliseconds(),
-		blockHeader.Bits,
-		blockHeader.Nonce,
-		blockHeader.DAAScore,
-		blockHeader.BlueScore,
-		blockHeader.BlueWork,
-		blockHeader.PruningPoint,
-	)
+// 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
@@ -95,6 +77,7 @@ func DomainTransactionToMsgTx(domainTransaction *externalapi.DomainTransaction)
 		LockTime:     domainTransaction.LockTime,
 		SubnetworkID: domainTransaction.SubnetworkID,
 		Gas:          domainTransaction.Gas,
+		PayloadHash:  domainTransaction.PayloadHash,
 		Payload:      domainTransaction.Payload,
 	}
 }
@@ -111,7 +94,6 @@ func domainTransactionInputToTxIn(domainTransactionInput *externalapi.DomainTran
 		PreviousOutpoint: *domainOutpointToOutpoint(domainTransactionInput.PreviousOutpoint),
 		SignatureScript:  domainTransactionInput.SignatureScript,
 		Sequence:         domainTransactionInput.Sequence,
-		SigOpCount:       domainTransactionInput.SigOpCount,
 	}
 }
 
@@ -145,6 +127,7 @@ func MsgTxToDomainTransaction(msgTx *MsgTx) *externalapi.DomainTransaction {
 		LockTime:     msgTx.LockTime,
 		SubnetworkID: msgTx.SubnetworkID,
 		Gas:          msgTx.Gas,
+		PayloadHash:  msgTx.PayloadHash,
 		Payload:      payload,
 	}
 }
@@ -160,7 +143,6 @@ func txInToDomainTransactionInput(txIn *TxIn) *externalapi.DomainTransactionInpu
 	return &externalapi.DomainTransactionInput{
 		PreviousOutpoint: *outpointToDomainOutpoint(&txIn.PreviousOutpoint), //TODO
 		SignatureScript:  txIn.SignatureScript,
-		SigOpCount:       txIn.SigOpCount,
 		Sequence:         txIn.Sequence,
 	}
 }
@@ -171,380 +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 {
-		previousOutpoint, err := RPCOutpointToDomainOutpoint(input.PreviousOutpoint)
-		if err != nil {
-			return nil, err
-		}
-		signatureScript, err := hex.DecodeString(input.SignatureScript)
-		if err != nil {
-			return nil, err
-		}
-		inputs[i] = &externalapi.DomainTransactionInput{
-			PreviousOutpoint: *previousOutpoint,
-			SignatureScript:  signatureScript,
-			Sequence:         input.Sequence,
-			SigOpCount:       input.SigOpCount,
-		}
-	}
-	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},
-		}
-	}
-
-	subnetworkID, err := subnetworks.FromString(rpcTransaction.SubnetworkID)
-	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,
-		Payload:      payload,
-	}, nil
-}
-
-// RPCOutpointToDomainOutpoint converts RPCOutpoint to  DomainOutpoint
-func RPCOutpointToDomainOutpoint(outpoint *RPCOutpoint) (*externalapi.DomainOutpoint, error) {
-	transactionID, err := transactionid.FromString(outpoint.TransactionID)
-	if err != nil {
-		return nil, err
-	}
-	return &externalapi.DomainOutpoint{
-		TransactionID: *transactionID,
-		Index:         outpoint.Index,
-	}, nil
-}
-
-// RPCUTXOEntryToUTXOEntry converts RPCUTXOEntry to UTXOEntry
-func RPCUTXOEntryToUTXOEntry(entry *RPCUTXOEntry) (externalapi.UTXOEntry, error) {
-	script, err := hex.DecodeString(entry.ScriptPublicKey.Script)
-	if err != nil {
-		return nil, err
-	}
-
-	return utxo.NewUTXOEntry(
-		entry.Amount,
-		&externalapi.ScriptPublicKey{
-			Script:  script,
-			Version: entry.ScriptPublicKey.Version,
-		},
-		entry.IsCoinbase,
-		entry.BlockDAAScore,
-	), 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,
-			SigOpCount:       input.SigOpCount,
-		}
-	}
-	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 := transaction.SubnetworkID.String()
-	payload := hex.EncodeToString(transaction.Payload)
-	return &RPCTransaction{
-		Version:      transaction.Version,
-		Inputs:       inputs,
-		Outputs:      outputs,
-		LockTime:     transaction.LockTime,
-		SubnetworkID: subnetworkID,
-		Gas:          transaction.LockTime,
-		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] = outpointAndUTXOEntryPairToDomainOutpointAndUTXOEntryPair(outpointAndUTXOEntryPair)
-	}
-	return domainOutpointAndUTXOEntryPairs
-}
-
-func outpointAndUTXOEntryPairToDomainOutpointAndUTXOEntryPair(
-	outpointAndUTXOEntryPair *OutpointAndUTXOEntryPair) *externalapi.OutpointAndUTXOEntryPair {
-	return &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.BlockDAAScore,
-		),
-	}
-}
-
-// 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(),
-				BlockDAAScore:   outpointAndUTXOEntryPair.UTXOEntry.BlockDAAScore(),
-			},
-		}
-	}
-	return domainOutpointAndUTXOEntryPairs
-}
-
-// DomainBlockToRPCBlock converts DomainBlocks to RPCBlocks
-func DomainBlockToRPCBlock(block *externalapi.DomainBlock) *RPCBlock {
-	parents := make([]*RPCBlockLevelParents, len(block.Header.Parents()))
-	for i, blockLevelParents := range block.Header.Parents() {
-		parents[i] = &RPCBlockLevelParents{
-			ParentHashes: hashes.ToStrings(blockLevelParents),
-		}
-	}
-	header := &RPCBlockHeader{
-		Version:              uint32(block.Header.Version()),
-		Parents:              parents,
-		HashMerkleRoot:       block.Header.HashMerkleRoot().String(),
-		AcceptedIDMerkleRoot: block.Header.AcceptedIDMerkleRoot().String(),
-		UTXOCommitment:       block.Header.UTXOCommitment().String(),
-		Timestamp:            block.Header.TimeInMilliseconds(),
-		Bits:                 block.Header.Bits(),
-		Nonce:                block.Header.Nonce(),
-		DAAScore:             block.Header.DAAScore(),
-		BlueScore:            block.Header.BlueScore(),
-		BlueWork:             block.Header.BlueWork().Text(16),
-		PruningPoint:         block.Header.PruningPoint().String(),
-	}
-	transactions := make([]*RPCTransaction, len(block.Transactions))
-	for i, transaction := range block.Transactions {
-		transactions[i] = DomainTransactionToRPCTransaction(transaction)
-	}
-	return &RPCBlock{
-		Header:       header,
-		Transactions: transactions,
-	}
-}
-
-// RPCBlockToDomainBlock converts `block` into a DomainBlock
-func RPCBlockToDomainBlock(block *RPCBlock) (*externalapi.DomainBlock, error) {
-	parents := make([]externalapi.BlockLevelParents, len(block.Header.Parents))
-	for i, blockLevelParents := range block.Header.Parents {
-		parents[i] = make(externalapi.BlockLevelParents, len(blockLevelParents.ParentHashes))
-		for j, parentHash := range blockLevelParents.ParentHashes {
-			var err error
-			parents[i][j], err = externalapi.NewDomainHashFromString(parentHash)
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-	hashMerkleRoot, err := externalapi.NewDomainHashFromString(block.Header.HashMerkleRoot)
-	if err != nil {
-		return nil, err
-	}
-	acceptedIDMerkleRoot, err := externalapi.NewDomainHashFromString(block.Header.AcceptedIDMerkleRoot)
-	if err != nil {
-		return nil, err
-	}
-	utxoCommitment, err := externalapi.NewDomainHashFromString(block.Header.UTXOCommitment)
-	if err != nil {
-		return nil, err
-	}
-	blueWork, success := new(big.Int).SetString(block.Header.BlueWork, 16)
-	if !success {
-		return nil, errors.Errorf("failed to parse blue work: %s", block.Header.BlueWork)
-	}
-	pruningPoint, err := externalapi.NewDomainHashFromString(block.Header.PruningPoint)
-	if err != nil {
-		return nil, err
-	}
-	header := blockheader.NewImmutableBlockHeader(
-		uint16(block.Header.Version),
-		parents,
-		hashMerkleRoot,
-		acceptedIDMerkleRoot,
-		utxoCommitment,
-		block.Header.Timestamp,
-		block.Header.Bits,
-		block.Header.Nonce,
-		block.Header.DAAScore,
-		block.Header.BlueScore,
-		blueWork,
-		pruningPoint)
-	transactions := make([]*externalapi.DomainTransaction, len(block.Transactions))
-	for i, transaction := range block.Transactions {
-		domainTransaction, err := RPCTransactionToDomainTransaction(transaction)
-		if err != nil {
-			return nil, err
-		}
-		transactions[i] = domainTransaction
-	}
-	return &externalapi.DomainBlock{
-		Header:       header,
-		Transactions: transactions,
-	}, nil
-}
-
-// BlockWithTrustedDataToDomainBlockWithTrustedData converts *MsgBlockWithTrustedData to *externalapi.BlockWithTrustedData
-func BlockWithTrustedDataToDomainBlockWithTrustedData(block *MsgBlockWithTrustedData) *externalapi.BlockWithTrustedData {
-	daaWindow := make([]*externalapi.TrustedDataDataDAABlock, len(block.DAAWindow))
-	for i, daaBlock := range block.DAAWindow {
-		daaWindow[i] = &externalapi.TrustedDataDataDAABlock{
-			Block:        MsgBlockToDomainBlock(daaBlock.Block),
-			GHOSTDAGData: ghostdagDataToDomainGHOSTDAGData(daaBlock.GHOSTDAGData),
-		}
-	}
-
-	ghostdagData := make([]*externalapi.BlockGHOSTDAGDataHashPair, len(block.GHOSTDAGData))
-	for i, datum := range block.GHOSTDAGData {
-		ghostdagData[i] = &externalapi.BlockGHOSTDAGDataHashPair{
-			Hash:         datum.Hash,
-			GHOSTDAGData: ghostdagDataToDomainGHOSTDAGData(datum.GHOSTDAGData),
-		}
-	}
-
-	return &externalapi.BlockWithTrustedData{
-		Block:        MsgBlockToDomainBlock(block.Block),
-		DAAScore:     block.DAAScore,
-		DAAWindow:    daaWindow,
-		GHOSTDAGData: ghostdagData,
-	}
-}
-
-func ghostdagDataToDomainGHOSTDAGData(data *BlockGHOSTDAGData) *externalapi.BlockGHOSTDAGData {
-	bluesAnticoneSizes := make(map[externalapi.DomainHash]externalapi.KType, len(data.BluesAnticoneSizes))
-	for _, pair := range data.BluesAnticoneSizes {
-		bluesAnticoneSizes[*pair.BlueHash] = pair.AnticoneSize
-	}
-	return externalapi.NewBlockGHOSTDAGData(
-		data.BlueScore,
-		data.BlueWork,
-		data.SelectedParent,
-		data.MergeSetBlues,
-		data.MergeSetReds,
-		bluesAnticoneSizes,
-	)
-}
-
-func domainGHOSTDAGDataGHOSTDAGData(data *externalapi.BlockGHOSTDAGData) *BlockGHOSTDAGData {
-	bluesAnticoneSizes := make([]*BluesAnticoneSizes, 0, len(data.BluesAnticoneSizes()))
-	for blueHash, anticoneSize := range data.BluesAnticoneSizes() {
-		blueHashCopy := blueHash
-		bluesAnticoneSizes = append(bluesAnticoneSizes, &BluesAnticoneSizes{
-			BlueHash:     &blueHashCopy,
-			AnticoneSize: anticoneSize,
-		})
-	}
-
-	return &BlockGHOSTDAGData{
-		BlueScore:          data.BlueScore(),
-		BlueWork:           data.BlueWork(),
-		SelectedParent:     data.SelectedParent(),
-		MergeSetBlues:      data.MergeSetBlues(),
-		MergeSetReds:       data.MergeSetReds(),
-		BluesAnticoneSizes: bluesAnticoneSizes,
-	}
-}
-
-// DomainBlockWithTrustedDataToBlockWithTrustedData converts *externalapi.BlockWithTrustedData to *MsgBlockWithTrustedData
-func DomainBlockWithTrustedDataToBlockWithTrustedData(block *externalapi.BlockWithTrustedData) *MsgBlockWithTrustedData {
-	daaWindow := make([]*TrustedDataDataDAABlock, len(block.DAAWindow))
-	for i, daaBlock := range block.DAAWindow {
-		daaWindow[i] = &TrustedDataDataDAABlock{
-			Block:        DomainBlockToMsgBlock(daaBlock.Block),
-			GHOSTDAGData: domainGHOSTDAGDataGHOSTDAGData(daaBlock.GHOSTDAGData),
-		}
-	}
-
-	ghostdagData := make([]*BlockGHOSTDAGDataHashPair, len(block.GHOSTDAGData))
-	for i, datum := range block.GHOSTDAGData {
-		ghostdagData[i] = &BlockGHOSTDAGDataHashPair{
-			Hash:         datum.Hash,
-			GHOSTDAGData: domainGHOSTDAGDataGHOSTDAGData(datum.GHOSTDAGData),
-		}
-	}
-
-	return &MsgBlockWithTrustedData{
-		Block:        DomainBlockToMsgBlock(block.Block),
-		DAAScore:     block.DAAScore,
-		DAAWindow:    daaWindow,
-		GHOSTDAGData: ghostdagData,
-	}
-}
-
-// MsgPruningPointProofToDomainPruningPointProof converts *MsgPruningPointProof to *externalapi.PruningPointProof
-func MsgPruningPointProofToDomainPruningPointProof(pruningPointProofMessage *MsgPruningPointProof) *externalapi.PruningPointProof {
-	headers := make([][]externalapi.BlockHeader, len(pruningPointProofMessage.Headers))
-	for blockLevel, blockLevelParents := range pruningPointProofMessage.Headers {
-		headers[blockLevel] = make([]externalapi.BlockHeader, len(blockLevelParents))
-		for i, header := range blockLevelParents {
-			headers[blockLevel][i] = BlockHeaderToDomainBlockHeader(header)
-		}
-	}
-	return &externalapi.PruningPointProof{
-		Headers: headers,
-	}
-}
-
-// DomainPruningPointProofToMsgPruningPointProof converts *externalapi.PruningPointProof to *MsgPruningPointProof
-func DomainPruningPointProofToMsgPruningPointProof(pruningPointProof *externalapi.PruningPointProof) *MsgPruningPointProof {
-	headers := make([][]*MsgBlockHeader, len(pruningPointProof.Headers))
-	for blockLevel, blockLevelParents := range pruningPointProof.Headers {
-		headers[blockLevel] = make([]*MsgBlockHeader, len(blockLevelParents))
-		for i, header := range blockLevelParents {
-			headers[blockLevel][i] = DomainBlockHeaderToBlockHeader(header)
-		}
-	}
-	return &MsgPruningPointProof{
-		Headers: headers,
-	}
-}

app/appmessage/message.go

@@ -41,31 +41,22 @@ const (
 	CmdPong
 	CmdRequestBlockLocator
 	CmdBlockLocator
+	CmdSelectedTip
+	CmdRequestSelectedTip
 	CmdInvRelayBlock
 	CmdRequestRelayBlocks
 	CmdInvTransaction
 	CmdRequestTransactions
+	CmdIBDBlock
 	CmdDoneHeaders
 	CmdTransactionNotFound
 	CmdReject
+	CmdHeader
 	CmdRequestNextHeaders
-	CmdRequestPruningPointUTXOSet
-	CmdPruningPointUTXOSetChunk
-	CmdUnexpectedPruningPoint
-	CmdIBDBlockLocator
-	CmdIBDBlockLocatorHighestHash
-	CmdIBDBlockLocatorHighestHashNotFound
-	CmdBlockHeaders
-	CmdRequestNextPruningPointUTXOSetChunk
-	CmdDonePruningPointUTXOSetChunks
-	CmdBlockWithTrustedData
-	CmdDoneBlocksWithTrustedData
-	CmdRequestPruningPointAndItsAnticone
-	CmdIBDBlock
+	CmdRequestIBDRootUTXOSetAndBlock
+	CmdIBDRootUTXOSetAndBlock
 	CmdRequestIBDBlocks
-	CmdPruningPoints
-	CmdRequestPruningPointProof
-	CmdPruningPointProof
+	CmdIBDRootNotFound
 
 	// rpc
 	CmdGetCurrentNetworkRequestMessage
@@ -90,15 +81,15 @@ const (
 	CmdAddPeerResponseMessage
 	CmdSubmitTransactionRequestMessage
 	CmdSubmitTransactionResponseMessage
-	CmdNotifyVirtualSelectedParentChainChangedRequestMessage
-	CmdNotifyVirtualSelectedParentChainChangedResponseMessage
-	CmdVirtualSelectedParentChainChangedNotificationMessage
+	CmdNotifyChainChangedRequestMessage
+	CmdNotifyChainChangedResponseMessage
+	CmdChainChangedNotificationMessage
 	CmdGetBlockRequestMessage
 	CmdGetBlockResponseMessage
 	CmdGetSubnetworkRequestMessage
 	CmdGetSubnetworkResponseMessage
-	CmdGetVirtualSelectedParentChainFromBlockRequestMessage
-	CmdGetVirtualSelectedParentChainFromBlockResponseMessage
+	CmdGetChainFromBlockRequestMessage
+	CmdGetChainFromBlockResponseMessage
 	CmdGetBlocksRequestMessage
 	CmdGetBlocksResponseMessage
 	CmdGetBlockCountRequestMessage
@@ -117,153 +108,88 @@ const (
 	CmdShutDownResponseMessage
 	CmdGetHeadersRequestMessage
 	CmdGetHeadersResponseMessage
-	CmdNotifyUTXOsChangedRequestMessage
-	CmdNotifyUTXOsChangedResponseMessage
-	CmdUTXOsChangedNotificationMessage
-	CmdStopNotifyingUTXOsChangedRequestMessage
-	CmdStopNotifyingUTXOsChangedResponseMessage
-	CmdGetUTXOsByAddressesRequestMessage
-	CmdGetUTXOsByAddressesResponseMessage
-	CmdGetVirtualSelectedParentBlueScoreRequestMessage
-	CmdGetVirtualSelectedParentBlueScoreResponseMessage
-	CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage
-	CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage
-	CmdVirtualSelectedParentBlueScoreChangedNotificationMessage
-	CmdBanRequestMessage
-	CmdBanResponseMessage
-	CmdUnbanRequestMessage
-	CmdUnbanResponseMessage
-	CmdGetInfoRequestMessage
-	CmdGetInfoResponseMessage
-	CmdNotifyPruningPointUTXOSetOverrideRequestMessage
-	CmdNotifyPruningPointUTXOSetOverrideResponseMessage
-	CmdPruningPointUTXOSetOverrideNotificationMessage
-	CmdStopNotifyingPruningPointUTXOSetOverrideRequestMessage
-	CmdStopNotifyingPruningPointUTXOSetOverrideResponseMessage
-	CmdEstimateNetworkHashesPerSecondRequestMessage
-	CmdEstimateNetworkHashesPerSecondResponseMessage
-	CmdNotifyVirtualDaaScoreChangedRequestMessage
-	CmdNotifyVirtualDaaScoreChangedResponseMessage
-	CmdVirtualDaaScoreChangedNotificationMessage
 )
 
 // ProtocolMessageCommandToString maps all MessageCommands to their string representation
 var ProtocolMessageCommandToString = map[MessageCommand]string{
-	CmdVersion:                             "Version",
-	CmdVerAck:                              "VerAck",
-	CmdRequestAddresses:                    "RequestAddresses",
-	CmdAddresses:                           "Addresses",
-	CmdRequestHeaders:                      "CmdRequestHeaders",
-	CmdBlock:                               "Block",
-	CmdTx:                                  "Tx",
-	CmdPing:                                "Ping",
-	CmdPong:                                "Pong",
-	CmdRequestBlockLocator:                 "RequestBlockLocator",
-	CmdBlockLocator:                        "BlockLocator",
-	CmdInvRelayBlock:                       "InvRelayBlock",
-	CmdRequestRelayBlocks:                  "RequestRelayBlocks",
-	CmdInvTransaction:                      "InvTransaction",
-	CmdRequestTransactions:                 "RequestTransactions",
-	CmdDoneHeaders:                         "DoneHeaders",
-	CmdTransactionNotFound:                 "TransactionNotFound",
-	CmdReject:                              "Reject",
-	CmdRequestNextHeaders:                  "RequestNextHeaders",
-	CmdRequestPruningPointUTXOSet:          "RequestPruningPointUTXOSet",
-	CmdPruningPointUTXOSetChunk:            "PruningPointUTXOSetChunk",
-	CmdUnexpectedPruningPoint:              "UnexpectedPruningPoint",
-	CmdIBDBlockLocator:                     "IBDBlockLocator",
-	CmdIBDBlockLocatorHighestHash:          "IBDBlockLocatorHighestHash",
-	CmdIBDBlockLocatorHighestHashNotFound:  "IBDBlockLocatorHighestHashNotFound",
-	CmdBlockHeaders:                        "BlockHeaders",
-	CmdRequestNextPruningPointUTXOSetChunk: "RequestNextPruningPointUTXOSetChunk",
-	CmdDonePruningPointUTXOSetChunks:       "DonePruningPointUTXOSetChunks",
-	CmdBlockWithTrustedData:                "BlockWithTrustedData",
-	CmdDoneBlocksWithTrustedData:           "DoneBlocksWithTrustedData",
-	CmdRequestPruningPointAndItsAnticone:   "RequestPruningPointAndItsAnticoneHeaders",
-	CmdIBDBlock:                            "IBDBlock",
-	CmdRequestIBDBlocks:                    "RequestIBDBlocks",
-	CmdPruningPoints:                       "PruningPoints",
-	CmdRequestPruningPointProof:            "RequestPruningPointProof",
-	CmdPruningPointProof:                   "PruningPointProof",
+	CmdVersion:                       "Version",
+	CmdVerAck:                        "VerAck",
+	CmdRequestAddresses:              "RequestAddresses",
+	CmdAddresses:                     "Addresses",
+	CmdRequestHeaders:                "RequestHeaders",
+	CmdBlock:                         "Block",
+	CmdTx:                            "Tx",
+	CmdPing:                          "Ping",
+	CmdPong:                          "Pong",
+	CmdRequestBlockLocator:           "RequestBlockLocator",
+	CmdBlockLocator:                  "BlockLocator",
+	CmdSelectedTip:                   "SelectedTip",
+	CmdRequestSelectedTip:            "RequestSelectedTip",
+	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",
-	CmdStopNotifyingUTXOsChangedRequestMessage:                    "StopNotifyingUTXOsChangedRequest",
-	CmdStopNotifyingUTXOsChangedResponseMessage:                   "StopNotifyingUTXOsChangedResponse",
-	CmdGetUTXOsByAddressesRequestMessage:                          "GetUTXOsByAddressesRequest",
-	CmdGetUTXOsByAddressesResponseMessage:                         "GetUTXOsByAddressesResponse",
-	CmdGetVirtualSelectedParentBlueScoreRequestMessage:            "GetVirtualSelectedParentBlueScoreRequest",
-	CmdGetVirtualSelectedParentBlueScoreResponseMessage:           "GetVirtualSelectedParentBlueScoreResponse",
-	CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage:  "NotifyVirtualSelectedParentBlueScoreChangedRequest",
-	CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage: "NotifyVirtualSelectedParentBlueScoreChangedResponse",
-	CmdVirtualSelectedParentBlueScoreChangedNotificationMessage:   "VirtualSelectedParentBlueScoreChangedNotification",
-	CmdBanRequestMessage:                                          "BanRequest",
-	CmdBanResponseMessage:                                         "BanResponse",
-	CmdUnbanRequestMessage:                                        "UnbanRequest",
-	CmdUnbanResponseMessage:                                       "UnbanResponse",
-	CmdGetInfoRequestMessage:                                      "GetInfoRequest",
-	CmdGetInfoResponseMessage:                                     "GeInfoResponse",
-	CmdNotifyPruningPointUTXOSetOverrideRequestMessage:            "NotifyPruningPointUTXOSetOverrideRequest",
-	CmdNotifyPruningPointUTXOSetOverrideResponseMessage:           "NotifyPruningPointUTXOSetOverrideResponse",
-	CmdPruningPointUTXOSetOverrideNotificationMessage:             "PruningPointUTXOSetOverrideNotification",
-	CmdStopNotifyingPruningPointUTXOSetOverrideRequestMessage:     "StopNotifyingPruningPointUTXOSetOverrideRequest",
-	CmdStopNotifyingPruningPointUTXOSetOverrideResponseMessage:    "StopNotifyingPruningPointUTXOSetOverrideResponse",
-	CmdEstimateNetworkHashesPerSecondRequestMessage:               "EstimateNetworkHashesPerSecondRequest",
-	CmdEstimateNetworkHashesPerSecondResponseMessage:              "EstimateNetworkHashesPerSecondResponse",
-	CmdNotifyVirtualDaaScoreChangedRequestMessage:                 "NotifyVirtualDaaScoreChangedRequest",
-	CmdNotifyVirtualDaaScoreChangedResponseMessage:                "NotifyVirtualDaaScoreChangedResponse",
-	CmdVirtualDaaScoreChangedNotificationMessage:                  "VirtualDaaScoreChangedNotification",
+	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

@@ -15,6 +15,19 @@ import (
 // backing array multiple times.
 const defaultTransactionAlloc = 2048
 
+// MaxMassAcceptedByBlock is the maximum total transaction mass a block may accept.
+const MaxMassAcceptedByBlock = 10000000
+
+// MaxMassPerTx is the maximum total mass a transaction may have.
+const MaxMassPerTx = MaxMassAcceptedByBlock / 2
+
+// MaxTxPerBlock is the maximum number of transactions that could
+// possibly fit into a block.
+const MaxTxPerBlock = (MaxMassAcceptedByBlock / minTxPayload) + 1
+
+// MaxBlockParents is the maximum allowed number of parents for block.
+const MaxBlockParents = 10
+
 // TxLoc holds locator data for the offset and length of where a transaction is
 // located within a MsgBlock data buffer.
 type TxLoc struct {
@@ -58,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.
@@ -21,18 +21,13 @@ func TestBlock(t *testing.T) {
 	pver := ProtocolVersion
 
 	// Block 1 header.
-	parents := blockOne.Header.Parents
+	parentHashes := blockOne.Header.ParentHashes
 	hashMerkleRoot := blockOne.Header.HashMerkleRoot
 	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
 	utxoCommitment := blockOne.Header.UTXOCommitment
 	bits := blockOne.Header.Bits
 	nonce := blockOne.Header.Nonce
-	daaScore := blockOne.Header.DAAScore
-	blueScore := blockOne.Header.BlueScore
-	blueWork := blockOne.Header.BlueWork
-	pruningPoint := blockOne.Header.PruningPoint
-	bh := NewBlockHeader(1, parents, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce,
-		daaScore, blueScore, blueWork, pruningPoint)
+	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
 
 	// Ensure the command is expected value.
 	wantCmd := MessageCommand(5)
@@ -115,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
 			}
 		}
@@ -132,11 +127,11 @@ 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,
-		Parents:              []externalapi.BlockLevelParents{[]*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash}},
+		Version:              1,
+		ParentHashes:         []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash},
 		HashMerkleRoot:       mainnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
@@ -161,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
+					},
 				},
 			}),
 	},
@@ -183,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,
@@ -209,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

@@ -5,12 +5,13 @@
 package appmessage
 
 import (
-	"math/big"
+	"math"
 
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/pkg/errors"
 )
 
 // BaseBlockHeaderPayload is the base number of bytes a block header can be,
@@ -36,10 +37,10 @@ type MsgBlockHeader struct {
 	baseMessage
 
 	// Version of the block. This is not the same as the protocol version.
-	Version uint16
+	Version int32
 
-	// Parents are the parent block hashes of the block in the DAG per superblock level.
-	Parents []externalapi.BlockLevelParents
+	// Hashes of the parent block headers in the blockDAG.
+	ParentHashes []*externalapi.DomainHash
 
 	// HashMerkleRoot is the merkle tree reference to hash of all transactions for the block.
 	HashMerkleRoot *externalapi.DomainHash
@@ -59,44 +60,49 @@ type MsgBlockHeader struct {
 
 	// Nonce used to generate the block.
 	Nonce uint64
+}
 
-	// DAASCore is the DAA score of the block.
-	DAAScore uint64
-
-	BlueScore uint64
-
-	// BlueWork is the blue work of the block.
-	BlueWork *big.Int
-
-	PruningPoint *externalapi.DomainHash
+// NumParentBlocks return the number of entries in ParentHashes
+func (h *MsgBlockHeader) NumParentBlocks() byte {
+	numParents := len(h.ParentHashes)
+	if numParents > math.MaxUint8 {
+		panic(errors.Errorf("number of parents is %d, which is more than one byte can fit", numParents))
+	}
+	return byte(numParents)
 }
 
 // BlockHash computes the block identifier hash for the given block header.
 func (h *MsgBlockHeader) BlockHash() *externalapi.DomainHash {
-	return consensushashing.HeaderHash(BlockHeaderToDomainBlockHeader(h))
+	return consensusserialization.HeaderHash(BlockHeaderToDomainBlockHeader(h))
+}
+
+// IsGenesis returns true iff this block is a genesis block
+func (h *MsgBlockHeader) IsGenesis() bool {
+	return h.NumParentBlocks() == 0
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (h *MsgBlockHeader) Command() MessageCommand {
+	return CmdHeader
 }
 
 // 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, parents []externalapi.BlockLevelParents, hashMerkleRoot *externalapi.DomainHash,
-	acceptedIDMerkleRoot *externalapi.DomainHash, utxoCommitment *externalapi.DomainHash, bits uint32, nonce,
-	daaScore, blueScore uint64, blueWork *big.Int, pruningPoint *externalapi.DomainHash) *MsgBlockHeader {
+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
 	// doesn't support better.
 	return &MsgBlockHeader{
 		Version:              version,
-		Parents:              parents,
+		ParentHashes:         parentHashes,
 		HashMerkleRoot:       hashMerkleRoot,
 		AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
 		UTXOCommitment:       utxoCommitment,
 		Timestamp:            mstime.Now(),
 		Bits:                 bits,
 		Nonce:                nonce,
-		DAAScore:             daaScore,
-		BlueScore:            blueScore,
-		BlueWork:             blueWork,
-		PruningPoint:         pruningPoint,
 	}
 }

app/appmessage/p2p_msgblockheader_test.go

@@ -5,34 +5,33 @@
 package appmessage
 
 import (
-	"math/big"
 	"reflect"
 	"testing"
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/kaspanet/kaspad/util/random"
 )
 
 // TestBlockHeader tests the MsgBlockHeader API.
 func TestBlockHeader(t *testing.T) {
-	nonce := uint64(0xba4d87a69924a93d)
+	nonce, err := random.Uint64()
+	if err != nil {
+		t.Errorf("random.Uint64: Error generating nonce: %v", err)
+	}
 
-	parents := []externalapi.BlockLevelParents{[]*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash}}
+	hashes := []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash}
 
 	merkleHash := mainnetGenesisMerkleRoot
 	acceptedIDMerkleRoot := exampleAcceptedIDMerkleRoot
 	bits := uint32(0x1d00ffff)
-	daaScore := uint64(123)
-	blueScore := uint64(456)
-	blueWork := big.NewInt(789)
-	pruningPoint := simnetGenesisHash
-	bh := NewBlockHeader(1, parents, merkleHash, acceptedIDMerkleRoot, exampleUTXOCommitment, bits, nonce,
-		daaScore, blueScore, blueWork, pruningPoint)
+	bh := NewBlockHeader(1, hashes, merkleHash, acceptedIDMerkleRoot, exampleUTXOCommitment, bits, nonce)
 
 	// Ensure we get the same data back out.
-	if !reflect.DeepEqual(bh.Parents, parents) {
-		t.Errorf("NewBlockHeader: wrong parents - got %v, want %v",
-			spew.Sprint(bh.Parents), spew.Sprint(parents))
+	if !reflect.DeepEqual(bh.ParentHashes, hashes) {
+		t.Errorf("NewBlockHeader: wrong prev hashes - got %v, want %v",
+			spew.Sprint(bh.ParentHashes), spew.Sprint(hashes))
 	}
 	if bh.HashMerkleRoot != merkleHash {
 		t.Errorf("NewBlockHeader: wrong merkle root - got %v, want %v",
@@ -46,20 +45,44 @@ func TestBlockHeader(t *testing.T) {
 		t.Errorf("NewBlockHeader: wrong nonce - got %v, want %v",
 			bh.Nonce, nonce)
 	}
-	if bh.DAAScore != daaScore {
-		t.Errorf("NewBlockHeader: wrong daaScore - got %v, want %v",
-			bh.DAAScore, daaScore)
+}
+
+func TestIsGenesis(t *testing.T) {
+	nonce := uint64(123123) // 0x1e0f3
+	bits := uint32(0x1d00ffff)
+	timestamp := mstime.UnixMilliseconds(0x495fab29000)
+
+	baseBlockHdr := &MsgBlockHeader{
+		Version:        1,
+		ParentHashes:   []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash},
+		HashMerkleRoot: mainnetGenesisMerkleRoot,
+		Timestamp:      timestamp,
+		Bits:           bits,
+		Nonce:          nonce,
 	}
-	if bh.BlueScore != blueScore {
-		t.Errorf("NewBlockHeader: wrong blueScore - got %v, want %v",
-			bh.BlueScore, blueScore)
+	genesisBlockHdr := &MsgBlockHeader{
+		Version:        1,
+		ParentHashes:   []*externalapi.DomainHash{},
+		HashMerkleRoot: mainnetGenesisMerkleRoot,
+		Timestamp:      timestamp,
+		Bits:           bits,
+		Nonce:          nonce,
 	}
-	if bh.BlueWork != blueWork {
-		t.Errorf("NewBlockHeader: wrong blueWork - got %v, want %v",
-			bh.BlueWork, blueWork)
+
+	tests := []struct {
+		in        *MsgBlockHeader // Block header to encode
+		isGenesis bool            // Expected result for call of .IsGenesis
+	}{
+		{genesisBlockHdr, true},
+		{baseBlockHdr, false},
 	}
-	if !bh.PruningPoint.Equal(pruningPoint) {
-		t.Errorf("NewBlockHeader: wrong pruningPoint - got %v, want %v",
-			bh.PruningPoint, pruningPoint)
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		isGenesis := test.in.IsGenesis()
+		if isGenesis != test.isGenesis {
+			t.Errorf("MsgBlockHeader.IsGenesis: #%d got: %t, want: %t",
+				i, isGenesis, test.isGenesis)
+		}
 	}
 }

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

@@ -1,54 +0,0 @@
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"math/big"
-)
-
-// MsgBlockWithTrustedData represents a kaspa BlockWithTrustedData message
-type MsgBlockWithTrustedData struct {
-	baseMessage
-
-	Block        *MsgBlock
-	DAAScore     uint64
-	DAAWindow    []*TrustedDataDataDAABlock
-	GHOSTDAGData []*BlockGHOSTDAGDataHashPair
-}
-
-// Command returns the protocol command string for the message
-func (msg *MsgBlockWithTrustedData) Command() MessageCommand {
-	return CmdBlockWithTrustedData
-}
-
-// NewMsgBlockWithTrustedData returns a new MsgBlockWithTrustedData.
-func NewMsgBlockWithTrustedData() *MsgBlockWithTrustedData {
-	return &MsgBlockWithTrustedData{}
-}
-
-// TrustedDataDataDAABlock is an appmessage representation of externalapi.TrustedDataDataDAABlock
-type TrustedDataDataDAABlock struct {
-	Block        *MsgBlock
-	GHOSTDAGData *BlockGHOSTDAGData
-}
-
-// BlockGHOSTDAGData is an appmessage representation of externalapi.BlockGHOSTDAGData
-type BlockGHOSTDAGData struct {
-	BlueScore          uint64
-	BlueWork           *big.Int
-	SelectedParent     *externalapi.DomainHash
-	MergeSetBlues      []*externalapi.DomainHash
-	MergeSetReds       []*externalapi.DomainHash
-	BluesAnticoneSizes []*BluesAnticoneSizes
-}
-
-// BluesAnticoneSizes is an appmessage representation of the BluesAnticoneSizes part of GHOSTDAG data.
-type BluesAnticoneSizes struct {
-	BlueHash     *externalapi.DomainHash
-	AnticoneSize externalapi.KType
-}
-
-// BlockGHOSTDAGDataHashPair is an appmessage representation of externalapi.BlockGHOSTDAGDataHashPair
-type BlockGHOSTDAGDataHashPair struct {
-	Hash         *externalapi.DomainHash
-	GHOSTDAGData *BlockGHOSTDAGData
-}

app/appmessage/p2p_msgdoneblockswithmetadata.go

@@ -1,21 +0,0 @@
-package appmessage
-
-// MsgDoneBlocksWithTrustedData implements the Message interface and represents a kaspa
-// DoneBlocksWithTrustedData message
-//
-// This message has no payload.
-type MsgDoneBlocksWithTrustedData struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgDoneBlocksWithTrustedData) Command() MessageCommand {
-	return CmdDoneBlocksWithTrustedData
-}
-
-// NewMsgDoneBlocksWithTrustedData returns a new kaspa DoneBlocksWithTrustedData message that conforms to the
-// Message interface.
-func NewMsgDoneBlocksWithTrustedData() *MsgDoneBlocksWithTrustedData {
-	return &MsgDoneBlocksWithTrustedData{}
-}

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

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

app/appmessage/p2p_msgibdblock_test.go

@@ -0,0 +1,65 @@
+// 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 (
+	"reflect"
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+// TestIBDBlock tests the MsgIBDBlock API.
+func TestIBDBlock(t *testing.T) {
+	pver := ProtocolVersion
+
+	// Block 1 header.
+	parentHashes := blockOne.Header.ParentHashes
+	hashMerkleRoot := blockOne.Header.HashMerkleRoot
+	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
+	utxoCommitment := blockOne.Header.UTXOCommitment
+	bits := blockOne.Header.Bits
+	nonce := blockOne.Header.Nonce
+	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(17)
+	msg := NewMsgIBDBlock(NewMsgBlock(bh))
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgIBDBlock: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+
+	// Ensure max payload is expected value for latest protocol version.
+	wantPayload := uint32(1024 * 1024 * 32)
+	maxPayload := msg.MaxPayloadLength(pver)
+	if maxPayload != wantPayload {
+		t.Errorf("MaxPayloadLength: wrong max payload length for "+
+			"protocol version %d - got %v, want %v", pver,
+			maxPayload, wantPayload)
+	}
+
+	// Ensure we get the same block header data back out.
+	if !reflect.DeepEqual(&msg.Header, bh) {
+		t.Errorf("NewMsgIBDBlock: wrong block header - got %v, want %v",
+			spew.Sdump(&msg.Header), spew.Sdump(bh))
+	}
+
+	// Ensure transactions are added properly.
+	tx := blockOne.Transactions[0].Copy()
+	msg.AddTransaction(tx)
+	if !reflect.DeepEqual(msg.Transactions, blockOne.Transactions) {
+		t.Errorf("AddTransaction: wrong transactions - got %v, want %v",
+			spew.Sdump(msg.Transactions),
+			spew.Sdump(blockOne.Transactions))
+	}
+
+	// Ensure transactions are properly cleared.
+	msg.ClearTransactions()
+	if len(msg.Transactions) != 0 {
+		t.Errorf("ClearTransactions: wrong transactions - got %v, want %v",
+			len(msg.Transactions), 0)
+	}
+}

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

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

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

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

app/appmessage/p2p_msgpong_test.go

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

app/appmessage/p2p_msgpruningpointproof.go

@@ -1,20 +0,0 @@
-package appmessage
-
-// MsgPruningPointProof represents a kaspa PruningPointProof message
-type MsgPruningPointProof struct {
-	baseMessage
-
-	Headers [][]*MsgBlockHeader
-}
-
-// Command returns the protocol command string for the message
-func (msg *MsgPruningPointProof) Command() MessageCommand {
-	return CmdPruningPointProof
-}
-
-// NewMsgPruningPointProof returns a new MsgPruningPointProof.
-func NewMsgPruningPointProof(headers [][]*MsgBlockHeader) *MsgPruningPointProof {
-	return &MsgPruningPointProof{
-		Headers: headers,
-	}
-}

app/appmessage/p2p_msgpruningpoints.go

@@ -1,20 +0,0 @@
-package appmessage
-
-// MsgPruningPoints represents a kaspa PruningPoints message
-type MsgPruningPoints struct {
-	baseMessage
-
-	Headers []*MsgBlockHeader
-}
-
-// Command returns the protocol command string for the message
-func (msg *MsgPruningPoints) Command() MessageCommand {
-	return CmdPruningPoints
-}
-
-// NewMsgPruningPoints returns a new MsgPruningPoints.
-func NewMsgPruningPoints(headers []*MsgBlockHeader) *MsgPruningPoints {
-	return &MsgPruningPoints{
-		Headers: headers,
-	}
-}

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
-	BlockDAAScore   uint64
-	IsCoinbase      bool
-}

app/appmessage/p2p_msgrequestblocklocator.go

@@ -5,13 +5,13 @@ import (
 )
 
 // MsgRequestBlockLocator implements the Message interface and represents a kaspa
-// RequestBlockLocator message. It is used to request a block locator between low
-// and high hash.
+// RequestBlockLocator message. It is used to request a block locator between high
+// and low hash.
 // The locator is returned via a locator message (MsgBlockLocator).
 type MsgRequestBlockLocator struct {
 	baseMessage
 	HighHash *externalapi.DomainHash
-	Limit    uint32
+	LowHash  *externalapi.DomainHash
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -23,9 +23,9 @@ func (msg *MsgRequestBlockLocator) Command() MessageCommand {
 // NewMsgRequestBlockLocator returns a new RequestBlockLocator message that conforms to the
 // Message interface using the passed parameters and defaults for the remaining
 // fields.
-func NewMsgRequestBlockLocator(highHash *externalapi.DomainHash, limit uint32) *MsgRequestBlockLocator {
+func NewMsgRequestBlockLocator(highHash, lowHash *externalapi.DomainHash) *MsgRequestBlockLocator {
 	return &MsgRequestBlockLocator{
 		HighHash: highHash,
-		Limit:    limit,
+		LowHash:  lowHash,
 	}
 }

app/appmessage/p2p_msgrequestblocklocator_test.go

@@ -4,19 +4,21 @@ 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)
 	}
 
 	// Ensure the command is expected value.
 	wantCmd := MessageCommand(9)
-	msg := NewMsgRequestBlockLocator(highHash, 0)
+	msg := NewMsgRequestBlockLocator(highHash, &externalapi.DomainHash{})
 	if cmd := msg.Command(); cmd != wantCmd {
 		t.Errorf("NewMsgRequestBlockLocator: wrong command - got %v want %v",
 			cmd, wantCmd)

app/appmessage/p2p_msgrequestheaders_test.go

@@ -7,34 +7,34 @@ package appmessage
 import (
 	"testing"
 
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 )
 
-// TestRequstIBDBlocks tests the MsgRequestIBDBlocks API.
+// 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) {
-		t.Errorf("NewMsgRequstIBDBlocks: wrong high hash - got %v, want %v",
+	if *msg.HighHash != *highHash {
+		t.Errorf("NewMsgRequstHeaders: wrong high hash - got %v, want %v",
 			msg.HighHash, highHash)
 	}
 
 	// Ensure the command is expected value.
 	wantCmd := MessageCommand(4)
 	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgRequstIBDBlocks: wrong command - got %v want %v",
+		t.Errorf("NewMsgRequstHeaders: wrong command - got %v want %v",
 			cmd, wantCmd)
 	}
 }

app/appmessage/p2p_msgrequestibdblocks.go

@@ -4,6 +4,10 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
+// MaxRequestIBDBlocksHashes is the maximum number of hashes that can
+// be in a single RequestIBDBlocks message.
+const MaxRequestIBDBlocksHashes = MaxInvPerMsg
+
 // MsgRequestIBDBlocks implements the Message interface and represents a kaspa
 // RequestIBDBlocks message. It is used to request blocks as part of the IBD
 // protocol.

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

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

app/appmessage/p2p_msgrequestpruningpointutxosetandblock.go

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

app/appmessage/p2p_msgrequestselectedtip.go

@@ -0,0 +1,21 @@
+package appmessage
+
+// MsgRequestSelectedTip implements the Message interface and represents a kaspa
+// RequestSelectedTip message. It is used to request the selected tip of another peer.
+//
+// This message has no payload.
+type MsgRequestSelectedTip struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestSelectedTip) Command() MessageCommand {
+	return CmdRequestSelectedTip
+}
+
+// NewMsgRequestSelectedTip returns a new kaspa RequestSelectedTip message that conforms to the
+// Message interface.
+func NewMsgRequestSelectedTip() *MsgRequestSelectedTip {
+	return &MsgRequestSelectedTip{}
+}

app/appmessage/p2p_msgrequestselectedtip_test.go

@@ -0,0 +1,20 @@
+// 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 (
+	"testing"
+)
+
+// TestRequestSelectedTip tests the MsgRequestSelectedTip API.
+func TestRequestSelectedTip(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(12)
+	msg := NewMsgRequestSelectedTip()
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgRequestSelectedTip: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/p2p_msgselectedtip.go

@@ -0,0 +1,28 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MsgSelectedTip implements the Message interface and represents a kaspa
+// selectedtip message. It is used to answer getseltip messages and tell
+// the asking peer what is the selected tip of this peer.
+type MsgSelectedTip struct {
+	baseMessage
+	// The selected tip hash of the generator of the message.
+	SelectedTipHash *externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgSelectedTip) Command() MessageCommand {
+	return CmdSelectedTip
+}
+
+// NewMsgSelectedTip returns a new kaspa selectedtip message that conforms to the
+// Message interface.
+func NewMsgSelectedTip(selectedTipHash *externalapi.DomainHash) *MsgSelectedTip {
+	return &MsgSelectedTip{
+		SelectedTipHash: selectedTipHash,
+	}
+}

app/appmessage/p2p_msgselectedtip_test.go

@@ -0,0 +1,18 @@
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// TestSelectedTip tests the MsgSelectedTip API.
+func TestSelectedTip(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(11)
+	msg := NewMsgSelectedTip(&externalapi.DomainHash{})
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgSelectedTip: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/p2p_msgtx.go

@@ -8,7 +8,11 @@ import (
 	"encoding/binary"
 	"strconv"
 
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
+
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 
 	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
 
@@ -37,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.
@@ -90,30 +94,28 @@ type TxIn struct {
 	PreviousOutpoint Outpoint
 	SignatureScript  []byte
 	Sequence         uint64
-	SigOpCount       byte
 }
 
 // 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, sigOpCount byte) *TxIn {
+func NewTxIn(prevOut *Outpoint, signatureScript []byte) *TxIn {
 	return &TxIn{
 		PreviousOutpoint: *prevOut,
 		SignatureScript:  signatureScript,
-		Sequence:         sequence,
-		SigOpCount:       sigOpCount,
+		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,
@@ -128,12 +130,13 @@ 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
 	SubnetworkID externalapi.DomainSubnetworkID
 	Gas          uint64
+	PayloadHash  externalapi.DomainHash
 	Payload      []byte
 }
 
@@ -159,12 +162,12 @@ func (msg *MsgTx) IsCoinBase() bool {
 
 // TxHash generates the Hash for the transaction.
 func (msg *MsgTx) TxHash() *externalapi.DomainHash {
-	return consensushashing.TransactionHash(MsgTxToDomainTransaction(msg))
+	return consensusserialization.TransactionHash(MsgTxToDomainTransaction(msg))
 }
 
 // TxID generates the Hash for the transaction without the signature script, gas and payload fields.
 func (msg *MsgTx) TxID() *externalapi.DomainTransactionID {
-	return consensushashing.TransactionID(MsgTxToDomainTransaction(msg))
+	return consensusserialization.TransactionID(MsgTxToDomainTransaction(msg))
 }
 
 // Copy creates a deep copy of a transaction so that the original does not get
@@ -179,6 +182,7 @@ func (msg *MsgTx) Copy() *MsgTx {
 		LockTime:     msg.LockTime,
 		SubnetworkID: msg.SubnetworkID,
 		Gas:          msg.Gas,
+		PayloadHash:  msg.PayloadHash,
 	}
 
 	if msg.Payload != nil {
@@ -208,7 +212,6 @@ func (msg *MsgTx) Copy() *MsgTx {
 			PreviousOutpoint: newOutpoint,
 			SignatureScript:  newScript,
 			Sequence:         oldTxIn.Sequence,
-			SigOpCount:       oldTxIn.SigOpCount,
 		}
 
 		// Finally, append this fully copied txin.
@@ -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 {
@@ -280,24 +283,30 @@ func newMsgTx(version uint16, txIn []*TxIn, txOut []*TxOut, subnetworkID *extern
 		txOut = make([]*TxOut, 0, defaultTxInOutAlloc)
 	}
 
+	var payloadHash externalapi.DomainHash
+	if *subnetworkID != subnetworks.SubnetworkIDNative {
+		payloadHash = *hashes.HashData(payload)
+	}
+
 	return &MsgTx{
 		Version:      version,
 		TxIn:         txIn,
 		TxOut:        txOut,
 		SubnetworkID: *subnetworkID,
 		Gas:          gas,
+		PayloadHash:  payloadHash,
 		Payload:      payload,
 		LockTime:     lockTime,
 	}
 }
 
 // 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)
@@ -306,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, 1)
+	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 := "93663e597f6c968d32d229002f76408edf30d6a0151ff679fc729812d8cb2acc"
-	txID1Str := "24079c6d2bdf602fc389cc307349054937744a9c8dc0f07c023e6af0e949a4e7"
+	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 := "8dafd1bec24527d8e3b443ceb0a3b92fffc0d60026317f890b2faf5e9afc177a"
-	wantHash2, err := externalapi.NewDomainHashFromString(hash2Str)
+	hash2Str := "c84f3009b337aaa3adeb2ffd41010d5f62dd773ca25b39c908a77da91f87b729"
+	wantHash2, err := hashes.FromString(hash2Str)
 	if err != nil {
 		t.Errorf("NewTxIDFromStr: %v", err)
 		return
 	}
 
-	id2Str := "89ffb49474637502d9059af38b8a95fc2f0d3baef5c801d7a9b9c8830671b711"
+	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_msgversion.go

@@ -53,6 +53,9 @@ type MsgVersion struct {
 	// on the appmessage. This has a max length of MaxUserAgentLen.
 	UserAgent string
 
+	// The selected tip hash of the generator of the version message.
+	SelectedTipHash *externalapi.DomainHash
+
 	// Don't announce transactions to peer.
 	DisableRelayTx bool
 
@@ -82,7 +85,7 @@ func (msg *MsgVersion) Command() MessageCommand {
 // Message interface using the passed parameters and defaults for the remaining
 // fields.
 func NewMsgVersion(addr *NetAddress, id *id.ID, network string,
-	subnetworkID *externalapi.DomainSubnetworkID) *MsgVersion {
+	selectedTipHash *externalapi.DomainHash, subnetworkID *externalapi.DomainSubnetworkID) *MsgVersion {
 
 	// Limit the timestamp to one millisecond precision since the protocol
 	// doesn't support better.
@@ -94,6 +97,7 @@ func NewMsgVersion(addr *NetAddress, id *id.ID, network string,
 		Address:         addr,
 		ID:              id,
 		UserAgent:       DefaultUserAgent,
+		SelectedTipHash: selectedTipHash,
 		DisableRelayTx:  false,
 		SubnetworkID:    subnetworkID,
 	}

app/appmessage/p2p_msgversion_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
 )
 
@@ -18,15 +19,16 @@ func TestVersion(t *testing.T) {
 	pver := ProtocolVersion
 
 	// Create version message data.
+	selectedTipHash := &externalapi.DomainHash{12, 34}
 	tcpAddrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 16111}
-	me := NewNetAddress(tcpAddrMe)
+	me := NewNetAddress(tcpAddrMe, SFNodeNetwork)
 	generatedID, err := id.GenerateID()
 	if err != nil {
 		t.Fatalf("id.GenerateID: %s", err)
 	}
 
 	// Ensure we get the correct data back out.
-	msg := NewMsgVersion(me, generatedID, "mainnet", nil)
+	msg := NewMsgVersion(me, generatedID, "mainnet", selectedTipHash, nil)
 	if msg.ProtocolVersion != pver {
 		t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
 			msg.ProtocolVersion, pver)
@@ -43,6 +45,10 @@ func TestVersion(t *testing.T) {
 		t.Errorf("NewMsgVersion: wrong user agent - got %v, want %v",
 			msg.UserAgent, DefaultUserAgent)
 	}
+	if *msg.SelectedTipHash != *selectedTipHash {
+		t.Errorf("NewMsgVersion: wrong selected tip hash - got %s, want %s",
+			msg.SelectedTipHash, selectedTipHash)
+	}
 	if msg.DisableRelayTx {
 		t.Errorf("NewMsgVersion: disable relay tx is not false by "+
 			"default - got %v, want %v", msg.DisableRelayTx, false)

app/appmessage/p2p_netaddress.go

@@ -15,6 +15,9 @@ type NetAddress struct {
 	// Last time the address was seen.
 	Timestamp mstime.Time
 
+	// Bitfield which identifies the services supported by the address.
+	Services ServiceFlag
+
 	// IP address of the peer.
 	IP net.IP
 
@@ -23,6 +26,17 @@ type NetAddress struct {
 	Port uint16
 }
 
+// HasService returns whether the specified service is supported by the address.
+func (na *NetAddress) HasService(service ServiceFlag) bool {
+	return na.Services&service == service
+}
+
+// AddService adds service as a supported service by the peer generating the
+// message.
+func (na *NetAddress) AddService(service ServiceFlag) {
+	na.Services |= service
+}
+
 // TCPAddress converts the NetAddress to *net.TCPAddr
 func (na *NetAddress) TCPAddress() *net.TCPAddr {
 	return &net.TCPAddr{
@@ -33,19 +47,20 @@ func (na *NetAddress) TCPAddress() *net.TCPAddr {
 
 // NewNetAddressIPPort returns a new NetAddress using the provided IP, port, and
 // supported services with defaults for the remaining fields.
-func NewNetAddressIPPort(ip net.IP, port uint16) *NetAddress {
-	return NewNetAddressTimestamp(mstime.Now(), ip, port)
+func NewNetAddressIPPort(ip net.IP, port uint16, services ServiceFlag) *NetAddress {
+	return NewNetAddressTimestamp(mstime.Now(), services, ip, port)
 }
 
 // NewNetAddressTimestamp returns a new NetAddress using the provided
 // timestamp, IP, port, and supported services. The timestamp is rounded to
 // single millisecond precision.
 func NewNetAddressTimestamp(
-	timestamp mstime.Time, ip net.IP, port uint16) *NetAddress {
+	timestamp mstime.Time, services ServiceFlag, ip net.IP, port uint16) *NetAddress {
 	// Limit the timestamp to one millisecond precision since the protocol
 	// doesn't support better.
 	na := NetAddress{
 		Timestamp: timestamp,
+		Services:  services,
 		IP:        ip,
 		Port:      port,
 	}
@@ -54,6 +69,6 @@ func NewNetAddressTimestamp(
 
 // NewNetAddress returns a new NetAddress using the provided TCP address and
 // supported services with defaults for the remaining fields.
-func NewNetAddress(addr *net.TCPAddr) *NetAddress {
-	return NewNetAddressIPPort(addr.IP, uint16(addr.Port))
+func NewNetAddress(addr *net.TCPAddr, services ServiceFlag) *NetAddress {
+	return NewNetAddressIPPort(addr.IP, uint16(addr.Port), services)
 }

app/appmessage/p2p_netaddress_test.go

@@ -15,7 +15,7 @@ func TestNetAddress(t *testing.T) {
 	port := 16111
 
 	// Test NewNetAddress.
-	na := NewNetAddress(&net.TCPAddr{IP: ip, Port: port})
+	na := NewNetAddress(&net.TCPAddr{IP: ip, Port: port}, 0)
 
 	// Ensure we get the same ip, port, and services back out.
 	if !na.IP.Equal(ip) {
@@ -25,4 +25,21 @@ func TestNetAddress(t *testing.T) {
 		t.Errorf("NetNetAddress: wrong port - got %v, want %v", na.Port,
 			port)
 	}
+	if na.Services != 0 {
+		t.Errorf("NetNetAddress: wrong services - got %v, want %v",
+			na.Services, 0)
+	}
+	if na.HasService(SFNodeNetwork) {
+		t.Errorf("HasService: SFNodeNetwork service is set")
+	}
+
+	// Ensure adding the full service node flag works.
+	na.AddService(SFNodeNetwork)
+	if na.Services != SFNodeNetwork {
+		t.Errorf("AddService: wrong services - got %v, want %v",
+			na.Services, SFNodeNetwork)
+	}
+	if !na.HasService(SFNodeNetwork) {
+		t.Errorf("HasService: SFNodeNetwork service not set")
+	}
 }

app/appmessage/p2p_unexpectedpruningpoint.go

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

app/appmessage/rpc_ban.go

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

app/appmessage/rpc_estimate_network_hashes_per_second.go

@@ -1,43 +0,0 @@
-package appmessage
-
-// EstimateNetworkHashesPerSecondRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type EstimateNetworkHashesPerSecondRequestMessage struct {
-	baseMessage
-	StartHash  string
-	WindowSize uint32
-}
-
-// Command returns the protocol command string for the message
-func (msg *EstimateNetworkHashesPerSecondRequestMessage) Command() MessageCommand {
-	return CmdEstimateNetworkHashesPerSecondRequestMessage
-}
-
-// NewEstimateNetworkHashesPerSecondRequestMessage returns a instance of the message
-func NewEstimateNetworkHashesPerSecondRequestMessage(startHash string, windowSize uint32) *EstimateNetworkHashesPerSecondRequestMessage {
-	return &EstimateNetworkHashesPerSecondRequestMessage{
-		StartHash:  startHash,
-		WindowSize: windowSize,
-	}
-}
-
-// EstimateNetworkHashesPerSecondResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type EstimateNetworkHashesPerSecondResponseMessage struct {
-	baseMessage
-	NetworkHashesPerSecond uint64
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *EstimateNetworkHashesPerSecondResponseMessage) Command() MessageCommand {
-	return CmdEstimateNetworkHashesPerSecondResponseMessage
-}
-
-// NewEstimateNetworkHashesPerSecondResponseMessage returns a instance of the message
-func NewEstimateNetworkHashesPerSecondResponseMessage(networkHashesPerSecond uint64) *EstimateNetworkHashesPerSecondResponseMessage {
-	return &EstimateNetworkHashesPerSecondResponseMessage{
-		NetworkHashesPerSecond: networkHashesPerSecond,
-	}
-}

app/appmessage/rpc_get_block.go

@@ -4,8 +4,9 @@ package appmessage
 // its respective RPC message
 type GetBlockRequestMessage struct {
 	baseMessage
-	Hash                string
-	IncludeTransactions bool
+	Hash                          string
+	SubnetworkID                  string
+	IncludeTransactionVerboseData bool
 }
 
 // Command returns the protocol command string for the message
@@ -14,10 +15,11 @@ func (msg *GetBlockRequestMessage) Command() MessageCommand {
 }
 
 // NewGetBlockRequestMessage returns a instance of the message
-func NewGetBlockRequestMessage(hash string, includeTransactions bool) *GetBlockRequestMessage {
+func NewGetBlockRequestMessage(hash string, subnetworkID string, includeTransactionVerboseData bool) *GetBlockRequestMessage {
 	return &GetBlockRequestMessage{
-		Hash:                hash,
-		IncludeTransactions: includeTransactions,
+		Hash:                          hash,
+		SubnetworkID:                  subnetworkID,
+		IncludeTransactionVerboseData: includeTransactionVerboseData,
 	}
 }
 
@@ -25,7 +27,7 @@ func NewGetBlockRequestMessage(hash string, includeTransactions bool) *GetBlockR
 // its respective RPC message
 type GetBlockResponseMessage struct {
 	baseMessage
-	Block *RPCBlock
+	BlockVerboseData *BlockVerboseData
 
 	Error *RPCError
 }
@@ -39,3 +41,69 @@ func (msg *GetBlockResponseMessage) Command() MessageCommand {
 func NewGetBlockResponseMessage() *GetBlockResponseMessage {
 	return &GetBlockResponseMessage{}
 }
+
+// BlockVerboseData holds verbose data about a block
+type BlockVerboseData struct {
+	Hash                   string
+	Version                int32
+	VersionHex             string
+	HashMerkleRoot         string
+	AcceptedIDMerkleRoot   string
+	UTXOCommitment         string
+	TxIDs                  []string
+	TransactionVerboseData []*TransactionVerboseData
+	Time                   int64
+	Nonce                  uint64
+	Bits                   string
+	Difficulty             float64
+	ParentHashes           []string
+	SelectedParentHash     string
+	BlueScore              uint64
+}
+
+// TransactionVerboseData holds verbose data about a transaction
+type TransactionVerboseData struct {
+	TxID                      string
+	Hash                      string
+	Size                      uint64
+	Version                   int32
+	LockTime                  uint64
+	SubnetworkID              string
+	Gas                       uint64
+	PayloadHash               string
+	Payload                   string
+	TransactionVerboseInputs  []*TransactionVerboseInput
+	TransactionVerboseOutputs []*TransactionVerboseOutput
+	BlockHash                 string
+	Time                      uint64
+	BlockTime                 uint64
+}
+
+// TransactionVerboseInput holds data about a transaction input
+type TransactionVerboseInput struct {
+	TxID        string
+	OutputIndex uint32
+	ScriptSig   *ScriptSig
+	Sequence    uint64
+}
+
+// ScriptSig holds data about a script signature
+type ScriptSig struct {
+	Asm string
+	Hex string
+}
+
+// TransactionVerboseOutput holds data about a transaction output
+type TransactionVerboseOutput struct {
+	Value        uint64
+	Index        uint32
+	ScriptPubKey *ScriptPubKeyResult
+}
+
+// ScriptPubKeyResult holds data about a script public key
+type ScriptPubKeyResult struct {
+	Asm     string
+	Hex     string
+	Type    string
+	Address string
+}

app/appmessage/rpc_get_block_count.go

@@ -1,7 +1,5 @@
 package appmessage
 
-import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-
 // GetBlockCountRequestMessage is an appmessage corresponding to
 // its respective RPC message
 type GetBlockCountRequestMessage struct {
@@ -22,8 +20,7 @@ func NewGetBlockCountRequestMessage() *GetBlockCountRequestMessage {
 // its respective RPC message
 type GetBlockCountResponseMessage struct {
 	baseMessage
-	BlockCount  uint64
-	HeaderCount uint64
+	BlockCount uint64
 
 	Error *RPCError
 }
@@ -34,9 +31,8 @@ func (msg *GetBlockCountResponseMessage) Command() MessageCommand {
 }
 
 // NewGetBlockCountResponseMessage returns a instance of the message
-func NewGetBlockCountResponseMessage(syncInfo *externalapi.SyncInfo) *GetBlockCountResponseMessage {
+func NewGetBlockCountResponseMessage(blockCount uint64) *GetBlockCountResponseMessage {
 	return &GetBlockCountResponseMessage{
-		BlockCount:  syncInfo.BlockCount,
-		HeaderCount: syncInfo.HeaderCount,
+		BlockCount: blockCount,
 	}
 }

app/appmessage/rpc_get_block_dag_info.go

@@ -22,13 +22,10 @@ type GetBlockDAGInfoResponseMessage struct {
 	baseMessage
 	NetworkName         string
 	BlockCount          uint64
-	HeaderCount         uint64
 	TipHashes           []string
 	VirtualParentHashes []string
 	Difficulty          float64
 	PastMedianTime      int64
-	PruningPointHash    string
-	VirtualDAAScore     uint64
 
 	Error *RPCError
 }

app/appmessage/rpc_get_block_template.go

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

app/appmessage/rpc_get_blocks.go

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

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

@@ -41,10 +41,11 @@ type GetConnectedPeerInfoMessage struct {
 	ID                        string
 	Address                   string
 	LastPingDuration          int64
+	SelectedTipHash           string
+	IsSyncNode                bool
 	IsOutbound                bool
 	TimeOffset                int64
 	UserAgent                 string
 	AdvertisedProtocolVersion uint32
 	TimeConnected             int64
-	IsIBDPeer                 bool
 }

app/appmessage/rpc_get_info.go

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

app/appmessage/rpc_get_mempool_entry.go

@@ -28,8 +28,8 @@ type GetMempoolEntryResponseMessage struct {
 
 // MempoolEntry represents a transaction in the mempool.
 type MempoolEntry struct {
-	Fee         uint64
-	Transaction *RPCTransaction
+	Fee                    uint64
+	TransactionVerboseData *TransactionVerboseData
 }
 
 // Command returns the protocol command string for the message
@@ -38,11 +38,11 @@ func (msg *GetMempoolEntryResponseMessage) Command() MessageCommand {
 }
 
 // NewGetMempoolEntryResponseMessage returns a instance of the message
-func NewGetMempoolEntryResponseMessage(fee uint64, transaction *RPCTransaction) *GetMempoolEntryResponseMessage {
+func NewGetMempoolEntryResponseMessage(fee uint64, transactionVerboseData *TransactionVerboseData) *GetMempoolEntryResponseMessage {
 	return &GetMempoolEntryResponseMessage{
 		Entry: &MempoolEntry{
-			Fee:         fee,
-			Transaction: transaction,
+			Fee:                    fee,
+			TransactionVerboseData: transactionVerboseData,
 		},
 	}
 }

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
-	AddedChainBlockHashes   []string
-
-	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,
-	addedChainBlockHashes []string) *GetVirtualSelectedParentChainFromBlockResponseMessage {
-
-	return &GetVirtualSelectedParentChainFromBlockResponseMessage{
-		RemovedChainBlockHashes: removedChainBlockHashes,
-		AddedChainBlockHashes:   addedChainBlockHashes,
-	}
-}

app/appmessage/rpc_notify_block_added.go

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

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
+	AcceptedTxIDs []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_pruning_point_utxo_set_override.go

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

app/appmessage/rpc_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_daa_score_changed.go

@@ -1,55 +0,0 @@
-package appmessage
-
-// NotifyVirtualDaaScoreChangedRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyVirtualDaaScoreChangedRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyVirtualDaaScoreChangedRequestMessage) Command() MessageCommand {
-	return CmdNotifyVirtualDaaScoreChangedRequestMessage
-}
-
-// NewNotifyVirtualDaaScoreChangedRequestMessage returns a instance of the message
-func NewNotifyVirtualDaaScoreChangedRequestMessage() *NotifyVirtualDaaScoreChangedRequestMessage {
-	return &NotifyVirtualDaaScoreChangedRequestMessage{}
-}
-
-// NotifyVirtualDaaScoreChangedResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyVirtualDaaScoreChangedResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyVirtualDaaScoreChangedResponseMessage) Command() MessageCommand {
-	return CmdNotifyVirtualDaaScoreChangedResponseMessage
-}
-
-// NewNotifyVirtualDaaScoreChangedResponseMessage returns a instance of the message
-func NewNotifyVirtualDaaScoreChangedResponseMessage() *NotifyVirtualDaaScoreChangedResponseMessage {
-	return &NotifyVirtualDaaScoreChangedResponseMessage{}
-}
-
-// VirtualDaaScoreChangedNotificationMessage is an appmessage corresponding to
-// its respective RPC message
-type VirtualDaaScoreChangedNotificationMessage struct {
-	baseMessage
-	VirtualDaaScore uint64
-}
-
-// Command returns the protocol command string for the message
-func (msg *VirtualDaaScoreChangedNotificationMessage) Command() MessageCommand {
-	return CmdVirtualDaaScoreChangedNotificationMessage
-}
-
-// NewVirtualDaaScoreChangedNotificationMessage returns a instance of the message
-func NewVirtualDaaScoreChangedNotificationMessage(
-	virtualDaaScore uint64) *VirtualDaaScoreChangedNotificationMessage {
-
-	return &VirtualDaaScoreChangedNotificationMessage{
-		VirtualDaaScore: virtualDaaScore,
-	}
-}

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,57 +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
-	AddedChainBlockHashes   []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,
-	addedChainBlocks []string) *VirtualSelectedParentChainChangedNotificationMessage {
-
-	return &VirtualSelectedParentChainChangedNotificationMessage{
-		RemovedChainBlockHashes: removedChainBlockHashes,
-		AddedChainBlockHashes:   addedChainBlocks,
-	}
-}

app/appmessage/rpc_stop_notifying_utxos_changed.go

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

app/appmessage/rpc_submit_block.go

@@ -4,7 +4,7 @@ package appmessage
 // its respective RPC message
 type SubmitBlockRequestMessage struct {
 	baseMessage
-	Block *RPCBlock
+	Block *MsgBlock
 }
 
 // Command returns the protocol command string for the message
@@ -13,39 +13,17 @@ func (msg *SubmitBlockRequestMessage) Command() MessageCommand {
 }
 
 // NewSubmitBlockRequestMessage returns a instance of the message
-func NewSubmitBlockRequestMessage(block *RPCBlock) *SubmitBlockRequestMessage {
+func NewSubmitBlockRequestMessage(block *MsgBlock) *SubmitBlockRequestMessage {
 	return &SubmitBlockRequestMessage{
 		Block: block,
 	}
 }
 
-// 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
@@ -53,48 +31,7 @@ func (msg *SubmitBlockResponseMessage) Command() MessageCommand {
 	return CmdSubmitBlockResponseMessage
 }
 
-// NewSubmitBlockResponseMessage returns an instance of the message
+// NewSubmitBlockResponseMessage returns a instance of the message
 func NewSubmitBlockResponseMessage() *SubmitBlockResponseMessage {
 	return &SubmitBlockResponseMessage{}
 }
-
-// RPCBlock is a kaspad block representation meant to be
-// used over RPC
-type RPCBlock struct {
-	Header       *RPCBlockHeader
-	Transactions []*RPCTransaction
-	VerboseData  *RPCBlockVerboseData
-}
-
-// RPCBlockHeader is a kaspad block header representation meant to be
-// used over RPC
-type RPCBlockHeader struct {
-	Version              uint32
-	Parents              []*RPCBlockLevelParents
-	HashMerkleRoot       string
-	AcceptedIDMerkleRoot string
-	UTXOCommitment       string
-	Timestamp            int64
-	Bits                 uint32
-	Nonce                uint64
-	DAAScore             uint64
-	BlueScore            uint64
-	BlueWork             string
-	PruningPoint         string
-}
-
-// RPCBlockLevelParents holds parent hashes for one block level
-type RPCBlockLevelParents struct {
-	ParentHashes []string
-}
-
-// RPCBlockVerboseData holds verbose data about a block
-type RPCBlockVerboseData struct {
-	Hash               string
-	Difficulty         float64
-	SelectedParentHash string
-	TransactionIDs     []string
-	IsHeaderOnly       bool
-	BlueScore          uint64
-	ChildrenHashes     []string
-}

app/appmessage/rpc_submit_transaction.go

@@ -4,8 +4,7 @@ package appmessage
 // its respective RPC message
 type SubmitTransactionRequestMessage struct {
 	baseMessage
-	Transaction *RPCTransaction
-	AllowOrphan bool
+	Transaction *MsgTx
 }
 
 // Command returns the protocol command string for the message
@@ -14,10 +13,9 @@ func (msg *SubmitTransactionRequestMessage) Command() MessageCommand {
 }
 
 // NewSubmitTransactionRequestMessage returns a instance of the message
-func NewSubmitTransactionRequestMessage(transaction *RPCTransaction, allowOrphan bool) *SubmitTransactionRequestMessage {
+func NewSubmitTransactionRequestMessage(transaction *MsgTx) *SubmitTransactionRequestMessage {
 	return &SubmitTransactionRequestMessage{
 		Transaction: transaction,
-		AllowOrphan: allowOrphan,
 	}
 }
 
@@ -25,7 +23,7 @@ func NewSubmitTransactionRequestMessage(transaction *RPCTransaction, allowOrphan
 // its respective RPC message
 type SubmitTransactionResponseMessage struct {
 	baseMessage
-	TransactionID string
+	TxID string
 
 	Error *RPCError
 }
@@ -36,80 +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
-	Payload      string
-	VerboseData  *RPCTransactionVerboseData
-}
-
-// RPCTransactionInput is a kaspad transaction input representation
-// meant to be used over RPC
-type RPCTransactionInput struct {
-	PreviousOutpoint *RPCOutpoint
-	SignatureScript  string
-	Sequence         uint64
-	SigOpCount       byte
-	VerboseData      *RPCTransactionInputVerboseData
-}
-
-// 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
-	VerboseData     *RPCTransactionOutputVerboseData
-}
-
-// 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
-	BlockDAAScore   uint64
-	IsCoinbase      bool
-}
-
-// RPCTransactionVerboseData holds verbose data about a transaction
-type RPCTransactionVerboseData struct {
-	TransactionID string
-	Hash          string
-	Mass          uint64
-	BlockHash     string
-	BlockTime     uint64
-}
-
-// RPCTransactionInputVerboseData holds data about a transaction input
-type RPCTransactionInputVerboseData struct {
-}
-
-// RPCTransactionOutputVerboseData holds data about a transaction output
-type RPCTransactionOutputVerboseData struct {
-	ScriptPublicKeyType    string
-	ScriptPublicKeyAddress string
-}

app/appmessage/rpc_unban.go

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

app/component_manager.go

@@ -4,19 +4,21 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
+	infrastructuredatabase "github.com/kaspanet/kaspad/infrastructure/db/database"
 
+	"github.com/kaspanet/kaspad/domain"
+
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol"
 	"github.com/kaspanet/kaspad/app/rpc"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus"
-	"github.com/kaspanet/kaspad/domain/utxoindex"
 	"github.com/kaspanet/kaspad/infrastructure/config"
-	infrastructuredatabase "github.com/kaspanet/kaspad/infrastructure/db/database"
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/dnsseed"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
 	"github.com/kaspanet/kaspad/util/panics"
 )
 
@@ -46,6 +48,8 @@ func (a *ComponentManager) Start() {
 		panics.Exit(log, fmt.Sprintf("Error starting the net adapter: %+v", err))
 	}
 
+	a.maybeSeedFromDNS()
+
 	a.connectionManager.Start()
 }
 
@@ -66,8 +70,6 @@ func (a *ComponentManager) Stop() {
 		log.Errorf("Error stopping the net adapter: %+v", err)
 	}
 
-	a.protocolManager.Close()
-
 	return
 }
 
@@ -76,16 +78,7 @@ func (a *ComponentManager) Stop() {
 func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database, interrupt chan<- struct{}) (
 	*ComponentManager, error) {
 
-	consensusConfig := consensus.Config{
-		Params:                          *cfg.ActiveNetParams,
-		IsArchival:                      cfg.IsArchivalNode,
-		EnableSanityCheckPruningUTXOSet: cfg.EnableSanityCheckPruningUTXOSet,
-	}
-	mempoolConfig := mempool.DefaultConfig(&consensusConfig.Params)
-	mempoolConfig.MaximumOrphanTransactionCount = cfg.MaxOrphanTxs
-	mempoolConfig.MinimumRelayTransactionFee = cfg.MinRelayTxFee
-
-	domain, err := domain.New(&consensusConfig, mempoolConfig, db)
+	domain, err := domain.New(cfg.ActiveNetParams, db)
 	if err != nil {
 		return nil, err
 	}
@@ -95,21 +88,11 @@ func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database,
 		return nil, err
 	}
 
-	addressManager, err := addressmanager.New(addressmanager.NewConfig(cfg), db)
+	addressManager, err := addressmanager.New(addressmanager.NewConfig(cfg))
 	if err != nil {
 		return nil, err
 	}
 
-	var utxoIndex *utxoindex.UTXOIndex
-	if cfg.UTXOIndex {
-		utxoIndex, err = utxoindex.New(domain.Consensus(), db)
-		if err != nil {
-			return nil, err
-		}
-
-		log.Infof("UTXO index started")
-	}
-
 	connectionManager, err := connmanager.New(cfg, netAdapter, addressManager)
 	if err != nil {
 		return nil, err
@@ -118,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,
@@ -138,26 +121,35 @@ 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)
-	protocolManager.SetOnPruningPointUTXOSetOverrideHandler(rpcManager.NotifyPruningPointUTXOSetOverride)
 
 	return rpcManager
 }
 
+func (a *ComponentManager) maybeSeedFromDNS() {
+	if !a.cfg.DisableDNSSeed {
+		dnsseed.SeedFromDNS(a.cfg.NetParams(), a.cfg.DNSSeed, appmessage.SFNodeNetwork, false, nil,
+			a.cfg.Lookup, func(addresses []*appmessage.NetAddress) {
+				// Kaspad uses a lookup of the dns seeder here. Since seeder returns
+				// IPs of nodes and not its own IP, we can not know real IP of
+				// source. So we'll take first returned address as source.
+				a.addressManager.AddAddresses(addresses...)
+			})
+	}
+
+	if a.cfg.GRPCSeed != "" {
+		dnsseed.SeedFromGRPC(a.cfg.NetParams(), a.cfg.GRPCSeed, appmessage.SFNodeNetwork, false, nil,
+			func(addresses []*appmessage.NetAddress) {
+				a.addressManager.AddAddresses(addresses...)
+			})
+	}
+}
+
 // P2PNodeID returns the network ID associated with this ComponentManager
 func (a *ComponentManager) P2PNodeID() *id.ID {
 	return a.netAdapter.ID()

app/db_version.go

@@ -1,57 +0,0 @@
-package app
-
-import (
-	"os"
-	"path"
-	"strconv"
-
-	"github.com/pkg/errors"
-)
-
-const currentDatabaseVersion = 1
-
-func checkDatabaseVersion(dbPath string) (err error) {
-	versionFileName := versionFilePath(dbPath)
-
-	versionBytes, err := os.ReadFile(versionFileName)
-	if err != nil {
-		if os.IsNotExist(err) { // If version file doesn't exist, we assume that the database is new
-			return createDatabaseVersionFile(dbPath, versionFileName)
-		}
-		return err
-	}
-
-	databaseVersion, err := strconv.Atoi(string(versionBytes))
-	if err != nil {
-		return err
-	}
-
-	if databaseVersion != currentDatabaseVersion {
-		// TODO: Once there's more then one database version, it might make sense to add upgrade logic at this point
-		return errors.Errorf("Invalid database version %d. Expected version: %d", databaseVersion, currentDatabaseVersion)
-	}
-
-	return nil
-}
-
-func createDatabaseVersionFile(dbPath string, versionFileName string) error {
-	err := os.MkdirAll(dbPath, 0700)
-	if err != nil {
-		return err
-	}
-
-	versionFile, err := os.Create(versionFileName)
-	if err != nil {
-		return nil
-	}
-	defer versionFile.Close()
-
-	versionString := strconv.Itoa(currentDatabaseVersion)
-	_, err = versionFile.Write([]byte(versionString))
-	return err
-}
-
-func versionFilePath(dbPath string) string {
-	dbVersionFileName := path.Join(dbPath, "version")
-	return dbVersionFileName
-}

app/log.go

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

app/protocol/blocklogger/blocklogger.go

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

app/protocol/blocklogger/log.go

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

app/protocol/common/common.go

@@ -8,7 +8,7 @@ import (
 
 // DefaultTimeout is the default duration to wait for enqueuing/dequeuing
 // to/from routes.
-const DefaultTimeout = 120 * time.Second
+const DefaultTimeout = 30 * time.Second
 
 // ErrPeerWithSameIDExists signifies that a peer with the same ID already exist.
 var ErrPeerWithSameIDExists = errors.New("ready peer with the same ID already exists")

app/protocol/flowcontext/blocks.go

@@ -1,14 +1,13 @@
 package flowcontext
 
 import (
-	"time"
-
-	peerpkg "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/protocol/blocklogger"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/pkg/errors"
+	"sync/atomic"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
@@ -17,85 +16,61 @@ 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 {
-
-	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)
+func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock) error {
+	unorphanedBlocks, err := f.UnorphanBlocks(block)
 	if err != nil {
 		return err
 	}
 
-	log.Debugf("OnNewBlock: block %s unorphaned %d blocks", hash, len(unorphaningResults))
+	newBlocks := append([]*externalapi.DomainBlock{block}, unorphanedBlocks...)
+	for _, newBlock := range newBlocks {
+		blocklogger.LogBlock(block)
 
-	newBlocks := []*externalapi.DomainBlock{block}
-	newBlockInsertionResults := []*externalapi.BlockInsertionResult{blockInsertionResult}
-	for _, unorphaningResult := range unorphaningResults {
-		newBlocks = append(newBlocks, unorphaningResult.block)
-		newBlockInsertionResults = append(newBlockInsertionResults, unorphaningResult.blockInsertionResult)
-	}
-
-	allAcceptedTransactions := make([]*externalapi.DomainTransaction, 0)
-	for i, newBlock := range newBlocks {
-		log.Debugf("OnNewBlock: passing block %s transactions to mining manager", hash)
-		acceptedTransactions, err := f.Domain().MiningManager().HandleNewBlockTransactions(newBlock.Transactions)
-		if err != nil {
-			return err
-		}
-		allAcceptedTransactions = append(allAcceptedTransactions, acceptedTransactions...)
+		_ = 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)
+			err := f.onBlockAddedToDAGHandler(newBlock)
 			if err != nil {
 				return err
 			}
 		}
 	}
 
-	return f.broadcastTransactionsAfterBlockAdded(newBlocks, allAcceptedTransactions)
-}
-
-// OnPruningPointUTXOSetOverride calls the handler function whenever the UTXO set
-// resets due to pruning point change via IBD.
-func (f *FlowContext) OnPruningPointUTXOSetOverride() error {
-	if f.onPruningPointUTXOSetOverrideHandler != nil {
-		return f.onPruningPointUTXOSetOverrideHandler()
-	}
 	return nil
 }
 
 func (f *FlowContext) broadcastTransactionsAfterBlockAdded(
-	addedBlocks []*externalapi.DomainBlock, transactionsAcceptedToMempool []*externalapi.DomainTransaction) error {
+	block *externalapi.DomainBlock, transactionsAcceptedToMempool []*externalapi.DomainTransaction) error {
+
+	f.updateTransactionsToRebroadcast(block)
 
 	// Don't relay transactions when in IBD.
-	if f.IsIBDRunning() {
+	if atomic.LoadUint32(&f.isInIBD) != 0 {
 		return nil
 	}
 
 	var txIDsToRebroadcast []*externalapi.DomainTransactionID
 	if f.shouldRebroadcastTransactions() {
-		txsToRebroadcast, err := f.Domain().MiningManager().RevalidateHighPriorityTransactions()
-		if err != nil {
-			return err
-		}
-		txIDsToRebroadcast = consensushashing.TransactionIDs(txsToRebroadcast)
-		f.lastRebroadcastTime = time.Now()
+		txIDsToRebroadcast = f.txIDsToRebroadcast()
 	}
 
 	txIDsToBroadcast := make([]*externalapi.DomainTransactionID, len(transactionsAcceptedToMempool)+len(txIDsToRebroadcast))
 	for i, tx := range transactionsAcceptedToMempool {
-		txIDsToBroadcast[i] = consensushashing.TransactionID(tx)
+		txIDsToBroadcast[i] = consensusserialization.TransactionID(tx)
 	}
 	offset := len(transactionsAcceptedToMempool)
 	for i, txID := range txIDsToRebroadcast {
 		txIDsToBroadcast[offset+i] = txID
 	}
-	return f.EnqueueTransactionIDsForPropagation(txIDsToBroadcast)
+
+	if len(txIDsToBroadcast) == 0 {
+		return nil
+	}
+	if len(txIDsToBroadcast) > appmessage.MaxInvPerTxInvMsg {
+		txIDsToBroadcast = txIDsToBroadcast[:appmessage.MaxInvPerTxInvMsg]
+	}
+	inv := appmessage.NewMsgInvTransaction(txIDsToBroadcast)
+	return f.Broadcast(inv)
 }
 
 // SharedRequestedBlocks returns a *blockrelay.SharedRequestedBlocks for sharing
@@ -106,64 +81,17 @@ func (f *FlowContext) SharedRequestedBlocks() *blockrelay.SharedRequestedBlocks
 
 // AddBlock adds the given block to the DAG and propagates it.
 func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
-	if len(block.Transactions) == 0 {
-		return protocolerrors.Errorf(false, "cannot add header only block")
-	}
-
-	blockInsertionResult, err := f.Domain().Consensus().ValidateAndInsertBlock(block, true)
+	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", consensusserialization.BlockHash(block), err)
+			return nil
 		}
 		return err
 	}
-	err = f.OnNewBlock(block, blockInsertionResult)
+	err = f.OnNewBlock(block)
 	if err != nil {
 		return err
 	}
-	return f.Broadcast(appmessage.NewMsgInvBlock(consensushashing.BlockHash(block)))
-}
-
-// 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
-}
-
-// 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
-	}
-	f.ibdPeer = ibdPeer
-	log.Infof("IBD started")
-
-	return true
-}
-
-// UnsetIBDRunning unsets isInIBD
-func (f *FlowContext) UnsetIBDRunning() {
-	f.ibdPeerMutex.Lock()
-	defer f.ibdPeerMutex.Unlock()
-
-	if f.ibdPeer == nil {
-		panic("attempted to unset isInIBD when it was not set to begin with")
-	}
-
-	f.ibdPeer = nil
-}
-
-// 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
+	return f.Broadcast(appmessage.NewMsgInvBlock(consensusserialization.BlockHash(block)))
 }

app/protocol/flowcontext/errors.go

@@ -18,19 +18,14 @@ import (
 func (*FlowContext) HandleError(err error, flowName string, isStopping *uint32, errChan chan<- error) {
 	isErrRouteClosed := errors.Is(err, router.ErrRouteClosed)
 	if !isErrRouteClosed {
-		if protocolErr := (protocolerrors.ProtocolError{}); !errors.As(err, &protocolErr) {
+		if protocolErr := &(protocolerrors.ProtocolError{}); !errors.As(err, &protocolErr) {
 			panic(err)
 		}
 
-		log.Errorf("error from %s: %s", flowName, err)
+		log.Errorf("error from %s: %+v", flowName, err)
 	}
 
 	if atomic.AddUint32(isStopping, 1) == 1 {
 		errChan <- err
 	}
 }
-
-// IsRecoverableError returns whether the error is recoverable
-func (*FlowContext) IsRecoverableError(err error) bool {
-	return err == nil || errors.Is(err, router.ErrRouteClosed) || errors.As(err, &protocolerrors.ProtocolError{})
-}

app/protocol/flowcontext/flow_context.go

@@ -4,14 +4,12 @@ import (
 	"sync"
 	"time"
 
-	"github.com/kaspanet/kaspad/util/mstime"
-
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 
 	"github.com/kaspanet/kaspad/domain"
 
 	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
-	"github.com/kaspanet/kaspad/app/protocol/flows/transactionrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
@@ -22,11 +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
-
-// OnPruningPointUTXOSetOverrideHandler is a handle function that's triggered whenever the UTXO set
-// resets due to pruning point change via IBD.
-type OnPruningPointUTXOSetOverrideHandler func() error
+type OnBlockAddedToDAGHandler func(block *externalapi.DomainBlock) error
 
 // OnTransactionAddedToMempoolHandler is a handler function that's triggered
 // when a transaction is added to the mempool
@@ -41,31 +35,25 @@ type FlowContext struct {
 	addressManager    *addressmanager.AddressManager
 	connectionManager *connmanager.ConnectionManager
 
-	timeStarted int64
+	onBlockAddedToDAGHandler           OnBlockAddedToDAGHandler
+	onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler
 
-	onBlockAddedToDAGHandler             OnBlockAddedToDAGHandler
-	onPruningPointUTXOSetOverrideHandler OnPruningPointUTXOSetOverrideHandler
-	onTransactionAddedToMempoolHandler   OnTransactionAddedToMempoolHandler
-
-	lastRebroadcastTime         time.Time
-	sharedRequestedTransactions *transactionrelay.SharedRequestedTransactions
+	transactionsToRebroadcastLock sync.Mutex
+	transactionsToRebroadcast     map[externalapi.DomainTransactionID]*externalapi.DomainTransaction
+	lastRebroadcastTime           time.Time
+	sharedRequestedTransactions   *relaytransactions.SharedRequestedTransactions
 
 	sharedRequestedBlocks *blockrelay.SharedRequestedBlocks
 
-	ibdPeer      *peerpkg.Peer
-	ibdPeerMutex sync.RWMutex
+	isInIBD       uint32
+	startIBDMutex sync.Mutex
+	ibdPeer       *peerpkg.Peer
 
 	peers      map[id.ID]*peerpkg.Peer
 	peersMutex sync.RWMutex
 
 	orphans      map[externalapi.DomainHash]*externalapi.DomainBlock
 	orphansMutex sync.RWMutex
-
-	transactionIDsToPropagate        []*externalapi.DomainTransactionID
-	lastTransactionIDPropagationTime time.Time
-	transactionIDPropagationLock     sync.Mutex
-
-	shutdownChan chan struct{}
 }
 
 // New returns a new instance of FlowContext.
@@ -73,43 +61,24 @@ func New(cfg *config.Config, domain domain.Domain, addressManager *addressmanage
 	netAdapter *netadapter.NetAdapter, connectionManager *connmanager.ConnectionManager) *FlowContext {
 
 	return &FlowContext{
-		cfg:                              cfg,
-		netAdapter:                       netAdapter,
-		domain:                           domain,
-		addressManager:                   addressManager,
-		connectionManager:                connectionManager,
-		sharedRequestedTransactions:      transactionrelay.NewSharedRequestedTransactions(),
-		sharedRequestedBlocks:            blockrelay.NewSharedRequestedBlocks(),
-		peers:                            make(map[id.ID]*peerpkg.Peer),
-		orphans:                          make(map[externalapi.DomainHash]*externalapi.DomainBlock),
-		timeStarted:                      mstime.Now().UnixMilliseconds(),
-		transactionIDsToPropagate:        []*externalapi.DomainTransactionID{},
-		lastTransactionIDPropagationTime: time.Now(),
-		shutdownChan:                     make(chan struct{}),
+		cfg:                         cfg,
+		netAdapter:                  netAdapter,
+		domain:                      domain,
+		addressManager:              addressManager,
+		connectionManager:           connectionManager,
+		sharedRequestedTransactions: relaytransactions.NewSharedRequestedTransactions(),
+		sharedRequestedBlocks:       blockrelay.NewSharedRequestedBlocks(),
+		peers:                       make(map[id.ID]*peerpkg.Peer),
+		transactionsToRebroadcast:   make(map[externalapi.DomainTransactionID]*externalapi.DomainTransaction),
+		orphans:                     make(map[externalapi.DomainHash]*externalapi.DomainBlock),
 	}
 }
 
-// Close signals to all flows the the protocol manager is closed.
-func (f *FlowContext) Close() {
-	close(f.shutdownChan)
-}
-
-// ShutdownChan is a chan where flows can subscribe to shutdown
-// event.
-func (f *FlowContext) ShutdownChan() <-chan struct{} {
-	return f.shutdownChan
-}
-
 // SetOnBlockAddedToDAGHandler sets the onBlockAddedToDAG handler
 func (f *FlowContext) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler OnBlockAddedToDAGHandler) {
 	f.onBlockAddedToDAGHandler = onBlockAddedToDAGHandler
 }
 
-// SetOnPruningPointUTXOSetOverrideHandler sets the onPruningPointUTXOSetOverrideHandler handler
-func (f *FlowContext) SetOnPruningPointUTXOSetOverrideHandler(onPruningPointUTXOSetOverrideHandler OnPruningPointUTXOSetOverrideHandler) {
-	f.onPruningPointUTXOSetOverrideHandler = onPruningPointUTXOSetOverrideHandler
-}
-
 // SetOnTransactionAddedToMempoolHandler sets the onTransactionAddedToMempool handler
 func (f *FlowContext) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler) {
 	f.onTransactionAddedToMempoolHandler = onTransactionAddedToMempoolHandler

app/protocol/flowcontext/ibd.go

@@ -0,0 +1,130 @@
+package flowcontext
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"sync/atomic"
+	"time"
+
+	"github.com/kaspanet/kaspad/util/mstime"
+
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+)
+
+// StartIBDIfRequired selects a peer and starts IBD against it
+// if required
+func (f *FlowContext) StartIBDIfRequired() error {
+	f.startIBDMutex.Lock()
+	defer f.startIBDMutex.Unlock()
+
+	if f.IsInIBD() {
+		return nil
+	}
+
+	syncInfo, err := f.domain.Consensus().GetSyncInfo()
+	if err != nil {
+		return err
+	}
+
+	if syncInfo.State == externalapi.SyncStateRelay {
+		return nil
+	}
+
+	peer, err := f.selectPeerForIBD(syncInfo)
+	if err != nil {
+		return err
+	}
+	if peer == nil {
+		spawn("StartIBDIfRequired-requestSelectedTipsIfRequired", f.requestSelectedTipsIfRequired)
+		return nil
+	}
+
+	atomic.StoreUint32(&f.isInIBD, 1)
+	f.ibdPeer = peer
+	spawn("StartIBDIfRequired-peer.StartIBD", peer.StartIBD)
+
+	return nil
+}
+
+// IsInIBD is true if IBD is currently running
+func (f *FlowContext) IsInIBD() bool {
+	return atomic.LoadUint32(&f.isInIBD) != 0
+}
+
+// selectPeerForIBD returns the first peer whose selected tip
+// hash is not in our DAG
+func (f *FlowContext) selectPeerForIBD(syncInfo *externalapi.SyncInfo) (*peerpkg.Peer, error) {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+
+	for _, peer := range f.peers {
+		peerSelectedTipHash := peer.SelectedTipHash()
+
+		if f.IsOrphan(peerSelectedTipHash) {
+			continue
+		}
+
+		blockInfo, err := f.domain.Consensus().GetBlockInfo(peerSelectedTipHash)
+		if err != nil {
+			return nil, err
+		}
+		if syncInfo.State == externalapi.SyncStateHeadersFirst {
+			if !blockInfo.Exists {
+				return peer, nil
+			}
+		} else {
+			if blockInfo.Exists && blockInfo.BlockStatus == externalapi.StatusHeaderOnly &&
+				blockInfo.IsBlockInHeaderPruningPointFuture {
+				return peer, nil
+			}
+		}
+	}
+	return nil, nil
+}
+
+func (f *FlowContext) requestSelectedTipsIfRequired() {
+	dagTimeCurrent, err := f.shouldRequestSelectedTips()
+	if err != nil {
+		panic(err)
+	}
+	if dagTimeCurrent {
+		return
+	}
+	f.requestSelectedTips()
+}
+
+func (f *FlowContext) shouldRequestSelectedTips() (bool, error) {
+	const minDurationToRequestSelectedTips = time.Minute
+	virtualSelectedParent, err := f.domain.Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return false, err
+	}
+	virtualSelectedParentTime := mstime.UnixMilliseconds(virtualSelectedParent.Header.TimeInMilliseconds)
+	return mstime.Now().Sub(virtualSelectedParentTime) > minDurationToRequestSelectedTips, nil
+}
+
+func (f *FlowContext) requestSelectedTips() {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+
+	for _, peer := range f.peers {
+		peer.RequestSelectedTipIfRequired()
+	}
+}
+
+// FinishIBD finishes the current IBD flow and starts a new one if required.
+func (f *FlowContext) FinishIBD() error {
+	f.ibdPeer = nil
+
+	atomic.StoreUint32(&f.isInIBD, 0)
+
+	return f.StartIBDIfRequired()
+}
+
+// IBDPeer returns the currently active IBD peer.
+// Returns nil if we aren't currently in IBD
+func (f *FlowContext) IBDPeer() *peerpkg.Peer {
+	if !f.IsInIBD() {
+		return nil
+	}
+	return f.ibdPeer
+}

app/protocol/flowcontext/log.go

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

app/protocol/flowcontext/orphans.go

@@ -3,50 +3,21 @@ package flowcontext
 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/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 	"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()
 	defer f.orphansMutex.Unlock()
 
-	orphanHash := consensushashing.BlockHash(orphanBlock)
+	orphanHash := consensusserialization.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,32 +28,32 @@ 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()
 
 	// Find all the children of rootBlock among the orphans
 	// and add them to the process queue
-	rootBlockHash := consensushashing.BlockHash(rootBlock)
+	rootBlockHash := consensusserialization.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.DirectParents())
+		log.Tracef("Considering to unorphan block %s with parents %s",
+			orphanHash, orphanBlock.Header.ParentHashes)
 
 		canBeUnorphaned := true
-		for _, orphanBlockParentHash := range orphanBlock.Header.DirectParents() {
+		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 "+
+			if !orphanBlockParentInfo.Exists {
+				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.DirectParents() {
-			if orphanBlockParentHash.Equal(blockHash) {
+		for _, orphanBlockParentHash := range orphanBlock.Header.ParentHashes {
+			if *orphanBlockParentHash == *blockHash {
 				childOrphans = append(childOrphans, orphanHash)
 				break
 			}
@@ -143,71 +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, true)
+	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)
-			} else {
-				log.Debugf("Block %s was skipped when checking for orphan roots: "+
-					"exists: %t, status: %s", current, blockInfo.Exists, blockInfo.BlockStatus)
-			}
-			continue
-		}
-
-		for _, parent := range block.Header.DirectParents() {
-			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/flowcontext/transactions.go

@@ -4,23 +4,36 @@ import (
 	"time"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/flows/transactionrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 )
 
-// TransactionIDPropagationInterval is the interval between transaction IDs propagations
-const TransactionIDPropagationInterval = 500 * time.Millisecond
-
 // AddTransaction adds transaction to the mempool and propagates it.
-func (f *FlowContext) AddTransaction(tx *externalapi.DomainTransaction, allowOrphan bool) error {
-	acceptedTransactions, err := f.Domain().MiningManager().ValidateAndInsertTransaction(tx, true, allowOrphan)
+func (f *FlowContext) AddTransaction(tx *externalapi.DomainTransaction) error {
+	f.transactionsToRebroadcastLock.Lock()
+	defer f.transactionsToRebroadcastLock.Unlock()
+
+	err := f.Domain().MiningManager().ValidateAndInsertTransaction(tx, false)
 	if err != nil {
 		return err
 	}
 
-	acceptedTransactionIDs := consensushashing.TransactionIDs(acceptedTransactions)
-	return f.EnqueueTransactionIDsForPropagation(acceptedTransactionIDs)
+	transactionID := consensusserialization.TransactionID(tx)
+	f.transactionsToRebroadcast[*transactionID] = tx
+	inv := appmessage.NewMsgInvTransaction([]*externalapi.DomainTransactionID{transactionID})
+	return f.Broadcast(inv)
+}
+
+func (f *FlowContext) updateTransactionsToRebroadcast(block *externalapi.DomainBlock) {
+	f.transactionsToRebroadcastLock.Lock()
+	defer f.transactionsToRebroadcastLock.Unlock()
+	// Note: if the block is red, its transactions won't be rebroadcasted
+	// anymore, although they are not included in the UTXO set.
+	// This is probably ok, since red blocks are quite rare.
+	for _, tx := range block.Transactions {
+		delete(f.transactionsToRebroadcast, *consensusserialization.TransactionID(tx))
+	}
 }
 
 func (f *FlowContext) shouldRebroadcastTransactions() bool {
@@ -28,9 +41,22 @@ func (f *FlowContext) shouldRebroadcastTransactions() bool {
 	return time.Since(f.lastRebroadcastTime) > rebroadcastInterval
 }
 
-// SharedRequestedTransactions returns a *transactionrelay.SharedRequestedTransactions for sharing
+func (f *FlowContext) txIDsToRebroadcast() []*externalapi.DomainTransactionID {
+	f.transactionsToRebroadcastLock.Lock()
+	defer f.transactionsToRebroadcastLock.Unlock()
+
+	txIDs := make([]*externalapi.DomainTransactionID, len(f.transactionsToRebroadcast))
+	i := 0
+	for _, tx := range f.transactionsToRebroadcast {
+		txIDs[i] = consensusserialization.TransactionID(tx)
+		i++
+	}
+	return txIDs
+}
+
+// SharedRequestedTransactions returns a *relaytransactions.SharedRequestedTransactions for sharing
 // data about requested transactions between different peers.
-func (f *FlowContext) SharedRequestedTransactions() *transactionrelay.SharedRequestedTransactions {
+func (f *FlowContext) SharedRequestedTransactions() *relaytransactions.SharedRequestedTransactions {
 	return f.sharedRequestedTransactions
 }
 
@@ -41,42 +67,3 @@ func (f *FlowContext) OnTransactionAddedToMempool() {
 		f.onTransactionAddedToMempoolHandler()
 	}
 }
-
-// EnqueueTransactionIDsForPropagation add the given transactions IDs to a set of IDs to
-// propagate. The IDs will be broadcast to all peers within a single transaction Inv message.
-// The broadcast itself may happen only during a subsequent call to this method
-func (f *FlowContext) EnqueueTransactionIDsForPropagation(transactionIDs []*externalapi.DomainTransactionID) error {
-	f.transactionIDPropagationLock.Lock()
-	defer f.transactionIDPropagationLock.Unlock()
-
-	f.transactionIDsToPropagate = append(f.transactionIDsToPropagate, transactionIDs...)
-
-	return f.maybePropagateTransactions()
-}
-
-func (f *FlowContext) maybePropagateTransactions() error {
-	if time.Since(f.lastTransactionIDPropagationTime) < TransactionIDPropagationInterval &&
-		len(f.transactionIDsToPropagate) < appmessage.MaxInvPerTxInvMsg {
-		return nil
-	}
-
-	for len(f.transactionIDsToPropagate) > 0 {
-		transactionIDsToBroadcast := f.transactionIDsToPropagate
-		if len(transactionIDsToBroadcast) > appmessage.MaxInvPerTxInvMsg {
-			transactionIDsToBroadcast = f.transactionIDsToPropagate[:len(transactionIDsToBroadcast)]
-		}
-		log.Debugf("Transaction propagation: broadcasting %d transactions", len(transactionIDsToBroadcast))
-
-		inv := appmessage.NewMsgInvTransaction(transactionIDsToBroadcast)
-		err := f.Broadcast(inv)
-		if err != nil {
-			return err
-		}
-
-		f.transactionIDsToPropagate = f.transactionIDsToPropagate[len(transactionIDsToBroadcast):]
-	}
-
-	f.lastTransactionIDPropagationTime = time.Now()
-
-	return 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
 }
 
@@ -35,5 +37,6 @@ func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Rou
 		return protocolerrors.Errorf(true, "address count exceeded %d", addressmanager.GetAddressesMax)
 	}
 
-	return context.AddressManager().AddAddresses(msgAddresses.AddressList...)
+	context.AddressManager().AddAddresses(msgAddresses.AddressList...)
+	return nil
 }

app/protocol/flows/addressexchange/sendaddresses.go

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

app/protocol/flows/blockrelay/block_locator.go

@@ -1,27 +0,0 @@
-package blockrelay
-
-import (
-	"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/consensus/model/externalapi"
-)
-
-func (flow *handleRelayInvsFlow) sendGetBlockLocator(highHash *externalapi.DomainHash, limit uint32) error {
-	msgGetBlockLocator := appmessage.NewMsgRequestBlockLocator(highHash, limit)
-	return flow.outgoingRoute.Enqueue(msgGetBlockLocator)
-}
-
-func (flow *handleRelayInvsFlow) receiveBlockLocator() (blockLocatorHashes []*externalapi.DomainHash, err error) {
-	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
-	if err != nil {
-		return nil, err
-	}
-	msgBlockLocator, ok := message.(*appmessage.MsgBlockLocator)
-	if !ok {
-		return nil,
-			protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s, got: %s", appmessage.CmdBlockLocator, message.Command())
-	}
-	return msgBlockLocator.BlockLocatorHashes, nil
-}

app/protocol/flows/blockrelay/handle_ibd_block_locator.go

@@ -1,86 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/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
-			}
-
-			// The IBD block locator is checking only existing blocks with bodies.
-			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
-				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 {
-			log.Warnf("no hash was found in the blockLocator "+
-				"that was in the selected parent chain of targetHash %s", targetHash)
-
-			ibdBlockLocatorHighestHashNotFoundMessage := appmessage.NewMsgIBDBlockLocatorHighestHashNotFound()
-			err = outgoingRoute.Enqueue(ibdBlockLocatorHighestHashNotFoundMessage)
-			if err != nil {
-				return err
-			}
-		}
-	}
-}

app/protocol/flows/blockrelay/handle_pruning_point_and_its_anticone_requests.go

@@ -1,62 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// PruningPointAndItsAnticoneRequestsContext is the interface for the context needed for the HandlePruningPointAndItsAnticoneRequests flow.
-type PruningPointAndItsAnticoneRequestsContext interface {
-	Domain() domain.Domain
-}
-
-// HandlePruningPointAndItsAnticoneRequests listens to appmessage.MsgRequestPruningPointAndItsAnticone messages and sends
-// the pruning point and its anticone to the requesting peer.
-func HandlePruningPointAndItsAnticoneRequests(context PruningPointAndItsAnticoneRequestsContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
-
-	for {
-		_, err := incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-
-		log.Debugf("Got request for pruning point and its anticone from %s", peer)
-
-		pruningPointHeaders, err := context.Domain().Consensus().PruningPointHeaders()
-		if err != nil {
-			return err
-		}
-
-		msgPruningPointHeaders := make([]*appmessage.MsgBlockHeader, len(pruningPointHeaders))
-		for i, header := range pruningPointHeaders {
-			msgPruningPointHeaders[i] = appmessage.DomainBlockHeaderToBlockHeader(header)
-		}
-
-		err = outgoingRoute.Enqueue(appmessage.NewMsgPruningPoints(msgPruningPointHeaders))
-		if err != nil {
-			return err
-		}
-
-		blocks, err := context.Domain().Consensus().PruningPointAndItsAnticoneWithTrustedData()
-		if err != nil {
-			return err
-		}
-
-		for _, block := range blocks {
-			err = outgoingRoute.Enqueue(appmessage.DomainBlockWithTrustedDataToBlockWithTrustedData(block))
-			if err != nil {
-				return err
-			}
-		}
-
-		err = outgoingRoute.Enqueue(appmessage.NewMsgDoneBlocksWithTrustedData())
-		if err != nil {
-			return err
-		}
-
-		log.Debugf("Sent pruning point and its anticone to %s", peer)
-	}
-}

app/protocol/flows/blockrelay/handle_pruning_point_proof_requests.go

@@ -1,40 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// PruningPointProofRequestsContext is the interface for the context needed for the HandlePruningPointProofRequests flow.
-type PruningPointProofRequestsContext interface {
-	Domain() domain.Domain
-}
-
-// HandlePruningPointProofRequests listens to appmessage.MsgRequestPruningPointProof messages and sends
-// the pruning point proof to the requesting peer.
-func HandlePruningPointProofRequests(context PruningPointProofRequestsContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
-
-	for {
-		_, err := incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-
-		log.Debugf("Got request for pruning point proof from %s", peer)
-
-		pruningPointProof, err := context.Domain().Consensus().BuildPruningPointProof()
-		if err != nil {
-			return err
-		}
-		pruningPointProofMessage := appmessage.DomainPruningPointProofToMsgPruningPointProof(pruningPointProof)
-		err = outgoingRoute.Enqueue(pruningPointProofMessage)
-		if err != nil {
-			return err
-		}
-
-		log.Debugf("Sent pruning point proof to %s", peer)
-	}
-}

app/protocol/flows/blockrelay/handle_relay_block_requests.go

@@ -5,7 +5,6 @@ import (
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/pkg/errors"
 )
@@ -26,14 +25,13 @@ 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)
 			if err != nil {
 				return err
 			}
-			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
+			if !blockInfo.Exists {
 				return protocolerrors.Errorf(true, "block %s not found", hash)
 			}
 			block, err := context.Domain().Consensus().GetBlock(hash)
@@ -47,7 +45,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

@@ -8,32 +8,25 @@ import (
 	"github.com/kaspanet/kaspad/domain"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/blocks"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	mathUtil "github.com/kaspanet/kaspad/util/math"
 	"github.com/pkg/errors"
 )
 
-// orphanResolutionRange is the maximum amount of blockLocator hashes
-// to search for known blocks. See isBlockInOrphanResolutionRange for
-// further details
-var orphanResolutionRange uint32 = 5
-
 // RelayInvsContext is the interface for the context needed for the HandleRelayInvs flow.
 type RelayInvsContext interface {
 	Domain() domain.Domain
-	Config() *config.Config
-	OnNewBlock(block *externalapi.DomainBlock, blockInsertionResult *externalapi.BlockInsertionResult) error
-	OnPruningPointUTXOSetOverride() error
+	NetAdapter() *netadapter.NetAdapter
+	OnNewBlock(block *externalapi.DomainBlock) error
 	SharedRequestedBlocks() *SharedRequestedBlocks
+	StartIBDIfRequired() error
+	IsInIBD() bool
 	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
-	UnsetIBDRunning()
-	IsRecoverableError(err error) bool
 }
 
 type handleRelayInvsFlow struct {
@@ -60,7 +53,6 @@ func HandleRelayInvs(context RelayInvsContext, incomingRoute *router.Route, outg
 
 func (flow *handleRelayInvsFlow) start() error {
 	for {
-		log.Debugf("Waiting for inv")
 		inv, err := flow.readInv()
 		if err != nil {
 			return err
@@ -72,90 +64,39 @@ 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)
 			}
-			log.Debugf("Block %s already exists. continuing...", inv.Hash)
 			continue
 		}
 
 		if flow.IsOrphan(inv.Hash) {
-			log.Debugf("Block %s is a known orphan. Requesting its missing ancestors", inv.Hash)
-			err := flow.AddOrphanRootsToQueue(inv.Hash)
+			continue
+		}
+
+		err = flow.StartIBDIfRequired()
+		if err != nil {
+			return err
+		}
+		if flow.IsInIBD() {
+			// Block relay is disabled during IBD
+			continue
+		}
+
+		requestQueue := newHashesQueueSet()
+		requestQueue.enqueueIfNotExists(inv.Hash)
+
+		for requestQueue.len() > 0 {
+			err := flow.requestBlocks(requestQueue)
 			if err != nil {
 				return err
 			}
-			continue
-		}
-
-		// Block relay is disabled during IBD
-		if flow.IsIBDRunning() {
-			log.Debugf("Got block %s while in IBD. continuing...", inv.Hash)
-			continue
-		}
-
-		log.Debugf("Requesting block %s", inv.Hash)
-		block, exists, err := flow.requestBlock(inv.Hash)
-		if err != nil {
-			return err
-		}
-		if exists {
-			log.Debugf("Aborting requesting block %s because it already exists", inv.Hash)
-			continue
-		}
-
-		err = flow.banIfBlockIsHeaderOnly(block)
-		if err != nil {
-			return err
-		}
-
-		log.Debugf("Processing block %s", inv.Hash)
-		missingParents, blockInsertionResult, err := flow.processBlock(block)
-		if err != nil {
-			if errors.Is(err, ruleerrors.ErrPrunedBlock) {
-				log.Infof("Ignoring pruned block %s", inv.Hash)
-				continue
-			}
-
-			if errors.Is(err, ruleerrors.ErrDuplicateBlock) {
-				log.Infof("Ignoring duplicate block %s", inv.Hash)
-				continue
-			}
-			return err
-		}
-		if len(missingParents) > 0 {
-			log.Debugf("Block %s is orphan and has missing parents: %s", inv.Hash, missingParents)
-			err := flow.processOrphan(block)
-			if err != nil {
-				return err
-			}
-			continue
-		}
-
-		log.Debugf("Relaying block %s", inv.Hash)
-		err = flow.relayBlock(block)
-		if err != nil {
-			return err
-		}
-		log.Infof("Accepted block %s via relay", inv.Hash)
-		err = flow.OnNewBlock(block, blockInsertionResult)
-		if err != nil {
-			return err
 		}
 	}
 }
 
-func (flow *handleRelayInvsFlow) banIfBlockIsHeaderOnly(block *externalapi.DomainBlock) error {
-	if len(block.Transactions) == 0 {
-		return protocolerrors.Errorf(true, "sent header of %s block where expected block with body",
-			consensushashing.BlockHash(block))
-	}
-
-	return nil
-}
-
 func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error) {
 	if len(flow.invsQueue) > 0 {
 		var inv *appmessage.MsgInvRelayBlock
@@ -176,34 +117,68 @@ func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error)
 	return inv, nil
 }
 
-func (flow *handleRelayInvsFlow) requestBlock(requestHash *externalapi.DomainHash) (*externalapi.DomainBlock, bool, error) {
-	exists := flow.SharedRequestedBlocks().addIfNotExists(requestHash)
-	if exists {
-		return nil, true, nil
+func (flow *handleRelayInvsFlow) requestBlocks(requestQueue *hashesQueueSet) error {
+	numHashesToRequest := mathUtil.MinInt(appmessage.MaxRequestRelayBlocksHashes, requestQueue.len())
+	hashesToRequest := requestQueue.dequeue(numHashesToRequest)
+
+	pendingBlocks := map[externalapi.DomainHash]struct{}{}
+	var filteredHashesToRequest []*externalapi.DomainHash
+	for _, hash := range hashesToRequest {
+		exists := flow.SharedRequestedBlocks().addIfNotExists(hash)
+		if exists {
+			continue
+		}
+
+		// The block can become known from another peer in the process of orphan resolution
+		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(hash)
+		if err != nil {
+			return err
+		}
+		if blockInfo.Exists {
+			continue
+		}
+
+		pendingBlocks[*hash] = struct{}{}
+		filteredHashesToRequest = append(filteredHashesToRequest, hash)
 	}
 
-	// In case the function returns earlier than expected, we want to make sure flow.SharedRequestedBlocks() is
-	// clean from any pending blocks.
-	defer flow.SharedRequestedBlocks().remove(requestHash)
+	// Exit early if we've filtered out all the hashes
+	if len(filteredHashesToRequest) == 0 {
+		return nil
+	}
 
-	getRelayBlocksMsg := appmessage.NewMsgRequestRelayBlocks([]*externalapi.DomainHash{requestHash})
+	// In case the function returns earlier than expected, we want to make sure requestedBlocks is
+	// clean from any pending blocks.
+	defer flow.SharedRequestedBlocks().removeSet(pendingBlocks)
+
+	getRelayBlocksMsg := appmessage.NewMsgRequestRelayBlocks(filteredHashesToRequest)
 	err := flow.outgoingRoute.Enqueue(getRelayBlocksMsg)
 	if err != nil {
-		return nil, false, err
+		return err
 	}
 
-	msgBlock, err := flow.readMsgBlock()
-	if err != nil {
-		return nil, false, err
-	}
+	for len(pendingBlocks) > 0 {
+		msgBlock, err := flow.readMsgBlock()
+		if err != nil {
+			return err
+		}
 
-	block := appmessage.MsgBlockToDomainBlock(msgBlock)
-	blockHash := consensushashing.BlockHash(block)
-	if !blockHash.Equal(requestHash) {
-		return nil, false, protocolerrors.Errorf(true, "got unrequested block %s", blockHash)
-	}
+		block := appmessage.MsgBlockToDomainBlock(msgBlock)
+		blockHash := consensusserialization.BlockHash(block)
 
-	return block, false, nil
+		if _, ok := pendingBlocks[*blockHash]; !ok {
+			return protocolerrors.Errorf(true, "got unrequested block %s", blockHash)
+		}
+
+		err = flow.processAndRelayBlock(requestQueue, block)
+		if err != nil {
+			return err
+		}
+
+		delete(pendingBlocks, *blockHash)
+		flow.SharedRequestedBlocks().remove(blockHash)
+	}
+	return nil
 }
 
 // readMsgBlock returns the next msgBlock in msgChan, and populates invsQueue with any inv messages that meanwhile arrive.
@@ -227,103 +202,68 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock,
 	}
 }
 
-func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, *externalapi.BlockInsertionResult, error) {
-	blockHash := consensushashing.BlockHash(block)
-	blockInsertionResult, err := flow.Domain().Consensus().ValidateAndInsertBlock(block, true)
+func (flow *handleRelayInvsFlow) processAndRelayBlock(requestQueue *hashesQueueSet, block *externalapi.DomainBlock) error {
+	blockHash := consensusserialization.BlockHash(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 errors.Wrapf(err, "failed to process block %s", blockHash)
 		}
 
 		missingParentsError := &ruleerrors.ErrMissingParents{}
 		if errors.As(err, missingParentsError) {
-			return missingParentsError.MissingParentHashes, nil, nil
+			blueScore, err := blocks.ExtractBlueScore(block)
+			if err != nil {
+				return protocolerrors.Errorf(true, "received an orphan "+
+					"block %s with malformed blue score", blockHash)
+			}
+
+			const maxOrphanBlueScoreDiff = 10000
+			virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
+			if err != nil {
+				return err
+			}
+			selectedTipBlueScore, err := blocks.ExtractBlueScore(virtualSelectedParent)
+			if err != nil {
+				return err
+			}
+
+			if blueScore > selectedTipBlueScore+maxOrphanBlueScoreDiff {
+				log.Infof("Orphan block %s has blue score %d and the selected tip blue score is "+
+					"%d. Ignoring orphans with a blue score difference from the selected tip greater than %d",
+					blockHash, blueScore, selectedTipBlueScore, maxOrphanBlueScoreDiff)
+				return nil
+			}
+
+			// Add the orphan to the orphan pool
+			flow.AddOrphan(block)
+
+			// Request the parents for the orphan block from the peer that sent it.
+			for _, missingAncestor := range missingParentsError.MissingParentHashes {
+				requestQueue.enqueueIfNotExists(missingAncestor)
+			}
+			return 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, blockInsertionResult, nil
-}
+		log.Infof("Rejected block %s from %s: %s", blockHash, flow.peer, err)
 
-func (flow *handleRelayInvsFlow) relayBlock(block *externalapi.DomainBlock) error {
-	blockHash := consensushashing.BlockHash(block)
-	return flow.Broadcast(appmessage.NewMsgInvBlock(blockHash))
-}
-
-func (flow *handleRelayInvsFlow) processOrphan(block *externalapi.DomainBlock) error {
-	blockHash := consensushashing.BlockHash(block)
-
-	// Return if the block has been orphaned from elsewhere already
-	if flow.IsOrphan(blockHash) {
-		log.Debugf("Skipping orphan processing for block %s because it is already an orphan", blockHash)
-		return nil
+		return protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
 	}
 
-	// Add the block to the orphan set if it's within orphan resolution range
-	isBlockInOrphanResolutionRange, err := flow.isBlockInOrphanResolutionRange(blockHash)
-	if err != nil {
-		return err
-	}
-	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)
-	}
-
-	// Start IBD unless we already are in IBD
-	log.Debugf("Block %s is out of orphan resolution range. "+
-		"Attempting to start IBD against it.", blockHash)
-	return flow.runIBDIfNotRunning(block)
-}
-
-// isBlockInOrphanResolutionRange finds out whether the given blockHash should be
-// retrieved via the unorphaning mechanism or via IBD. This method sends a
-// getBlockLocator request to the peer with a limit of orphanResolutionRange.
-// In the response, if we know none of the hashes, we should retrieve the given
-// blockHash via IBD. Otherwise, via unorphaning.
-func (flow *handleRelayInvsFlow) isBlockInOrphanResolutionRange(blockHash *externalapi.DomainHash) (bool, error) {
-	err := flow.sendGetBlockLocator(blockHash, orphanResolutionRange)
-	if err != nil {
-		return false, err
-	}
-
-	blockLocatorHashes, err := flow.receiveBlockLocator()
-	if err != nil {
-		return false, err
-	}
-	for _, blockLocatorHash := range blockLocatorHashes {
-		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(blockLocatorHash)
-		if err != nil {
-			return false, err
-		}
-		if blockInfo.Exists && blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
-			return true, nil
-		}
-	}
-	return false, nil
-}
-
-func (flow *handleRelayInvsFlow) AddOrphanRootsToQueue(orphan *externalapi.DomainHash) error {
-	orphanRoots, orphanExists, err := flow.GetOrphanRoots(orphan)
+	err = flow.Broadcast(appmessage.NewMsgInvBlock(blockHash))
 	if err != nil {
 		return err
 	}
 
-	if !orphanExists {
-		log.Infof("Orphan block %s was missing from the orphan pool while requesting for its roots. This "+
-			"probably happened because it was randomly evicted immediately after it was added.", orphan)
+	log.Infof("Accepted block %s via relay", blockHash)
+
+	err = flow.StartIBDIfRequired()
+	if err != nil {
+		return err
+	}
+	err = flow.OnNewBlock(block)
+	if err != nil {
+		return err
 	}
 
-	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
 }